TL;DR: It is shown that the same technique used to prove that any VLSI implementation of a single output Boolean function has area-time complexity AT/sup 2/= Omega (n/Sup 2/) also proves that any OBDD representation of the function has Omega (c/sup n/) vertices for some c>1 but that the converse is not true.
Abstract: Lower-bound results on Boolean-function complexity under two different models are discussed. The first is an abstraction of tradeoffs between chip area and speed in very-large-scale-integrated (VLSI) circuits. The second is the ordered binary decision diagram (OBDD) representation used as a data structure for symbolically representing and manipulating Boolean functions. The lower bounds demonstrate the fundamental limitations of VLSI as an implementation medium, and that of the OBDD as a data structure. It is shown that the same technique used to prove that any VLSI implementation of a single output Boolean function has area-time complexity AT/sup 2/= Omega (n/sup 2/) also proves that any OBDD representation of the function has Omega (c/sup n/) vertices for some c>1 but that the converse is not true. An integer multiplier for word size n with outputs numbered 0 (least significant) through 2n-1 (most significant) is described. For the Boolean function representing either output i-1 or output 2n-i-1, where 1 >
TL;DR: In this article, the relation between the Walsh-Hadamard transform and the auto-correlation function of Boolean functions is used to study propagation characteristics of these functions, and a general framework is established to classify functions according to their propagation characteristics if a number of bits is kept constant.
Abstract: The relation between the Walsh-Hadamard transform and the auto-correlation function of Boolean functions is used to study propagation characteristics of these functions. The Strict Avalanche Criterion and the Perfect Nonlinearity Criterion are generalized in a Propagation Criterion of degree k. New properties and constructions for Boolean bent functions are given and also the extension of the definition to odd values of n is discussed. New properties of functions satisfying higher order SAC are derived. Finally a general framework is established to classify functions according to their propagation characteristics if a number of bits is kept constant.
TL;DR: One of the highlights of the present work is an exact characterization of the important class DET, which is shown that DET is exactly the class of functions that can be computed as the difference between the outputs of two counting logspace machines.
Abstract: The author examines various counting measures on space bounded nondeterministic auxiliary pushdown machines. In the main theorem, it is shown how a NAuxPDA may be simulated efficiently by a uniform family of Boolean circuits, which preserve the number of accepting paths in the NAuxPDA as the number of accepting subtrees in the Boolean circuit. The techniques used simulate the NAuxPDA in a novel way by considering the height and reversal bounds of an AuxPDA. One of the highlights of the present work is an exact characterization of the important class DET. It is shown that DET is exactly the class of functions that can be computed as the difference between the outputs of two counting logspace machines. >
TL;DR: A novel minimization procedure of prime implicant generation and covering that operates on symbolic outputs, rather than binary-valued outputs, is proposed for solving the output encoding problem and an exact algorithm is presented for state assignment.
Abstract: A novel minimization procedure of prime implicant generation and covering that operates on symbolic outputs, rather than binary-valued outputs, is proposed for solving the output encoding problem. An exact solution to this minimization problem is also an exact solution to the encoding problem. While this covering problem is more complex than the classic unate covering problem, a single logic minimization step replaces O(N-factorial) minimizations. The input encoding problem can be exactly solved using multiple-valued Boolean minimization. An exact algorithm is presented for state assignment by generalizing the proposed output encoding approach to the multiple-valued input case. Four-level Boolean minimization entails finding a cascaded pair of two-level logic functions that implement another logic function, such that the sum of the product terms in the two cascaded functions or truth tables is minimum. Four-level Boolean minimization can be formulated as an encoding problem and solved exactly using the proposed algorithms. Preliminary experimental results are presented which indicate that this approach is significantly more efficient than exhaustive search. Computationally efficient heuristic approaches based on the exact algorithms are proposed for output encoding, state assignment, and four-level Boolean minimization. >
TL;DR: The first correct proof that, for a random oracleA, PP A is properly contained in PSPACE A is given, and a new lower bound technique which applies to any Boolean function is introduced which yields tight bounds in the casef is parity.
Abstract: We consider the problem of approximating a Boolean functionf∶{0,1} n →{0,1} by the sign of an integer polynomialp of degreek. For us, a polynomialp(x) predicts the value off(x) if, wheneverp(x)≥0,f(x)=1, and wheneverp(x)<0,f(x)=0. A low-degree polynomialp is a good approximator forf if it predictsf at almost all points. Given a positive integerk, and a Boolean functionf, we ask, “how good is the best degreek approximation tof?” We introduce a new lower bound technique which applies to any Boolean function. We show that the lower bound technique yields tight bounds in the casef is parity. Minsky and Papert [10] proved that a perceptron cannot compute parity; our bounds indicate exactly how well a perceptron canapproximate it. As a consequence, we are able to give the first correct proof that, for a random oracleA, PP A is properly contained in PSPACE A . We are also able to prove the old AC0 exponential-size lower bounds in a new way. This allows us to prove the new result that an AC0 circuit with one majority gate cannot approximate parity. Our proof depends only on basic properties of integer polynomials.
TL;DR: The question of whether it is easier to solve two communication problems together rather than separately is related to the complexity of the composition of Boolean functions and an approach to separating NC/sup 1 /from P is outlined.
Abstract: Is it easier to solve two communication problems to- gether than separately? This question is related to the complexity of the composition of boolean functions. Based on this relationship, an approach to separating NC' from P is outlined. Furthermore, it is shown that the approach provides a new proof of the separation of monotone NC' from monotone P.
TL;DR: It turns out that, for any constant depth d, polynomial size sigmoid threshold circuits with polynomially bounded weights compute exactly the same Boolean functions as the corresponding circuits with Boolean threshold gates.
Abstract: The power of constant depth circuits with sigmoid (i.e., smooth) threshold gates for computing Boolean functions is examined. It is shown that, for depth 2, constant size circuits of this type are strictly more powerful than constant size Boolean threshold circuits (i.e., circuits with Boolean threshold gates). On the other hand it turns out that, for any constant depth d, polynomial size sigmoid threshold circuits with polynomially bounded weights compute exactly the same Boolean functions as the corresponding circuits with Boolean threshold gates. >
TL;DR: An analytical model for the behavior of dataflow graphs with data-dependent control flow that can be analyzed to construct an annotated schedule, or a static schedule that annotates each firing of an actor with the Boolean conditions under which that firing occurs.
Abstract: This paper describes an analytical model for the behavior of dataflow graphs with data-dependent control flow. The number of tokens produced or consumed by each actor is given as a symbolic function of the Booleans in the system. Long term averages can be analyzed to determine consistency of token flow rates, which in turn determines whether memory requirements are bounded. Short-term behavior can be analyzed to construct an annotated schedule, or a static schedule that annotates each firing of an actor with the Boolean conditions under which that firing occurs. Annotated schedules can be used to generate efficient implementations of the algorithms given by the dataflow graphs. >
TL;DR: The input encoding problem is shown to be equivalent to a two-level logic minimization, and a powerful heuristic, based on an iterative improvement technique, has been developed and implemented as a computer program: dichotomy-based symbolic input encoding technique (DIET).
Abstract: A novel theoretical formulation of the input encoding problem is presented, based on the concept of compatibility of dichotomies. The input encoding problem is shown to be equivalent to a two-level logic minimization. Three possible techniques to solve the encoding problem are discussed, based on: techniques borrowed from classical logic minimization (generation of prime dichotomies and solving the covering problem); graph coloring applied to the graph of incompatibility of dichotomies; and extraction of essential prime dichotomies followed by graph coloring. The extraction of essential prime dichotomies serves the same purpose as the extraction of essential prime implicants in logic minimization, in the sense that it reduces the size of the covering/graph coloring problem. The conditions of optimality of the solutions to the input encoding problem are discussed. For near-optimum results a powerful heuristic, based on an iterative improvement technique, has been developed and implemented as a computer program: dichotomy-based symbolic input encoding technique (DIET). The test results indicate the DIET compares favorably with KISS and NOVA in terms of the CPU time, is superior to both programs in terms of the encoding length, and requires considerably less memory. This method can be applied to the input encoding of combinational logic and the state assignment of finite state machines (FSMs) in both two-level and multilevel implementations. >
TL;DR: It is shown that if formulas constructed from error-prone three-input gates are used to compute Boolean functions, then a per-gate failure probability of 1/6 or more cannot be tolerated.
Abstract: It is shown that if formulas constructed from error-prone three-input gates are used to compute Boolean functions, then a per-gate failure probability of 1/6 or more cannot be tolerated. The result is shown to be tight if the per-gate failure probability is constant and precisely known. >
TL;DR: It is shown that the critical number crit(f) of a function f yields lower bound Omega (crit( f) log crit (f)) for the noisy circuit size, which implies that almost all n-input Boolean functions have noisy decision tree complexity Theta (n log n) in the static as well as in the dynamic case.
Abstract: Boolean circuits in which gates independently make errors with probability (at most) epsilon are considered. It is shown that the critical number crit(f) of a function f yields lower bound Omega (crit(f) log crit (f)) for the noisy circuit size. The lower bound is proved for an even stronger computational model, static Boolean decision trees with erroneous answers. A decision tree is static if the questions it asks do not depend on previous answers. The depth of such a tree provides a lower bound on the number of gates that depend directly on some input and hence on the size of a noisy circuit. Furthermore, it is shown that an Omega (n log n) lower bound holds for almost all Boolean n-input functions with respect to the depth of noisy dynamic decision trees. This bound is the best possible and implies that almost all n-input Boolean functions have noisy decision tree complexity Theta (n log n) in the static as well as in the dynamic case. >
TL;DR: This paper addresses the problem of learning boolean functions in query and mistake-bound models in the presence of irrelevant attributes by interested not only in learnability of concept classes, but also in whether the classes can be learned by an algorithm that is attribute-efficient in that the dependence of the mistake bound on the number of irrelevant Attributes is low.
Abstract: This paper addresses the problem of learning boolean functions in query and mistake-bound models in the presence of irrelevant attributes In learning a concept, a learner may observe a great many more attributes than those the concept depends upon, and in some sense the presence of extra, irrelevant attributes does not change the underlying concept being learned Because of this, we are interested not only in learnability of concept classes, but also in whether the classes can be learned by an algorithm that is attribute-efficient in that the dependence of the mistake bound (or number of queries) on the number of irrelevant attributes is low
TL;DR: In this article, a complete characterization of the autocorrelation function and Walsh spectrum of second order functions is given, and a new interpretation of the number of balanced second-order functions and a class of functions showing interesting properties is discussed.
Abstract: Boolean functions that satisfy higher order propagation criteria are studied. A complete characterization is given of the autocorrelation function and Walsh spectrum of second order functions. The number of second order functions satisfying PC(k) is related to a problem in coding theory and can be computed explicitly for k = 1, n - 1 and n. A new interpretation of the number of balanced second order functions is given and a class of functions showing interesting properties is discussed.
TL;DR: A new interpretation of the number of balanced second order functions is given and a class of functions showing interesting properties is discussed.
Abstract: Boolean functions that satisfy higher order propagation criteria are studied. A complete characterization is given of the autocorrelation function and Walsh spectrum of second order functions. The number of second order functions satisfying PC(k) is related to a problem in coding theory and can be computed explicitly for k = 1, n - 1 and n. A new interpretation of the number of balanced second order functions is given and a class of functions showing interesting properties is discussed.
TL;DR: A simple, but effective, heuristic method for synthesizing symmetric functions that detects and takes advantage of symmetry and is based on classic disjoint decomposition theory is fully developed from basic definitions.
Abstract: Designs of totally symmetric functions provided by logic synthesis systems have on average more than twice as many literals as best designs, while the designs of nonsymmetric functions have on average 20% more literals. A simple, but effective, heuristic method for synthesizing symmetric functions that detects and takes advantage of symmetry and is based on classic disjoint decomposition theory is fully developed from basic definitions. Functions are realized as Boolean networks with cost measured as the literal count of factored expressions. Programs based on the method almost always produce the best designs known to the authors. Two strategies for accepting decompositions are explored. They do produce different results in a few cases: examples are presented to show that neither always produces best designs. These programs are proposed as preprocessors for a comprehensive synthesis system. >
TL;DR: A novel method for verifying the equivalence of two Boolean functions that is hashed to an integer code by assigning random integer values to the input variables and evaluating its integer-valued representation.
Abstract: The authors present a novel method for verifying the equivalence of two Boolean functions. Each function is hashed to an integer code by assigning random integer values to the input variables and evaluating its integer-valued representation. The equivalence of two functions can be verified with a very low probability of error. The probability of error can be exponentially decreased by making multiple runs. Results indicate significant time and space advantages for this method over deterministic techniques. Some functions known to require space (and time) exponential in the number of input variables for deterministic verification require only polynomial resources using the proposed technique. >
TL;DR: It is proved that the reliable computation of any Boolean function with, sensitivity s requires Omega (s log s) gates if the gates of the circuit fail independently with a fixed positive probability.
Abstract: It is proved that the reliable computation of any Boolean function with, sensitivity s requires Omega (s log s) gates if the gates of the circuit fail independently with a fixed positive probability. The Omega (s log s) bound holds even if s is the block sensitivity instead of the sensitivity of the Boolean function. Some open problems are mentioned. >
TL;DR: A polynomial-time algorithm is presented for exactly learning the class of read-twice DNF formulas, i.e. Boolean formulas in disjunctive normal form where each variable appears at most twice.
Abstract: A polynomial-time algorithm is presented for exactly learning the class of read-twice DNF formulas, i.e. Boolean formulas in disjunctive normal form where each variable appears at most twice. The (standard) protocol used allows the learning algorithm to query whether a given assignment of Boolean variables satisfies the DNF formula to be learned (membership queries), as well as to obtain counterexamples to the correctness of its current hypothesis which can be any arbitrary DNF formula (equivalence queries). The formula output by the learning algorithm is logically equivalent to the formula to be learned. >
TL;DR: Presents a new methodology for the decomposition of Boolean functions, which is exclusively based on the utilization of function properties, and the main point in this connection is the 'groupability' of Boolean function properties.
Abstract: This Paper presents a new methodology for the decomposition of Boolean functions, which is exclusively based on the utilization of function properties. The main point in this connection is the "groupability" of Boolean functions. The analysis of uncompletely specified functions is carried out by means of Boolean differential equations. Examples demonstrate the efficiency of the automatic implementation.
TL;DR: A theoretical framework, based on Dempster-Shafer theory (DST), that accommodates vagueness and shows how imprecision can give rise to false-negative and false-positive inferences is proposed.
Abstract: Fault tree and reliability analyses frequently must rely on imprecise or vague input data. A theoretical framework, based on Dempster-Shafer theory (DST), that accommodates this vagueness and shows how imprecision can give rise to false-negative and false-positive inferences is proposed. DST assigns upper and lower bounds for the probability on elements of the state space. The author focuses on two consequences of vagueness: (1) the influence of imprecise or fuzzy input data on the parameters of the model to be observed, and (2) the result of sensory-device failures or of leaving out relevant variables that can cause false-negative and false-positive inferences. Imprecise input data are modeled through a three-valued logic derived from DST 'probability' assignments. False-negative and false-positive signals are illustrated by incorporating this information in an additional parameter that is coupled, with a Boolean AND gate, to each rule of the fault tree. The computational simplicity of incorporating DST probability assignments and the advantages of DST for reliability analyses are shown. >
TL;DR: Optimum and heuristic algorithms for the general decomposition of finite state machines such that the sum total of the number of product terms in the one-hot-coded and logic-minimized submachines is minimum or minimal are presented.
Abstract: Optimum and heuristic algorithms for the general decomposition of finite state machines (FSMs) such that the sum total of the number of product terms in the one-hot-coded and logic-minimized submachines is minimum or minimal are presented. This cost function is much more reflective of the area of an optimally state-assigned and minimized submachine than the number of states/edges in the submachine. The problem of optimum two-way FSM decomposition is formulated as one of symbolic output partitioning, and it is shown that this is an easier problem than optimum state assignment. A procedure of constrained prime implicant generation and covering that represents an optimum FSM decomposition algorithm, under the specified cost function, is described. It is shown that by means of this formulation, arbitrary decomposition topologies can be targeted by suitably modifying the constraints on the ability to encode during the covering. A novel iterative optimization strategy of symbolic implicant expansion and reduction, modified from two-level Boolean minimizers, that represents a heuristic algorithm based on the exact procedure is presented. Reduction and expansion are performed on functions with symbolic rather than binary-valued outputs. Preliminary experimental results that illustrate both the efficacy of the proposed algorithms and the validity of the selected cost function are presented. >
TL;DR: It is shown how general binary decision diagrams (BDDs), i.e., BDDs where input variables are allowed to appear multiple times along any path in the BDD, can be used to check for Boolean satisfiability.
Abstract: It is shown how general binary decision diagrams (BDDs), i.e., BDDs where input variables are allowed to appear multiple times along any path in the BDD, can be used to check for Boolean satisfiability. This satisfiability checking strategy is based on an input smoothing operation on general BDDs. Various input smoothing strategies for general BDDs are developed. In order to verify the equivalence of two functions f/sub 1/ and f/sub 2/, f/sub 1/(+)f/sub 2/ is checked for satisfiability. Using general BDDs different implementations of a 16*16 multiplier, a modified Achilles' heel function and a complex add-shift function were verified. It was not possible to construct OBDDs for any of the three functions. >
TL;DR: The relationship between two important means of representing Boolean functions, combinational circuits and ordered binary decision diagrams (OBDDs), and algorithms for register allocation can be used to determine a good variable order for OBDD construction are studied.
Abstract: The relationship between two important means of representing Boolean functions, combinational circuits and ordered binary decision diagrams (OBDDs), is studied. Circuit width is related to OBDD size. and it is shown how algorithms for register allocation can be used to determine a good variable order for OBDD construction. In particular, it is shown that if C has n inputs, moutputs, and width w(C), then there is a variable ordering for which the directed-acyclic-graph-based representation for C has at most n*m*2/sup w(C)/ modes. Since the width of a circuit is closely related to the number of registers required to evaluate the circuit, the result indicates that register allocation techniques can be used to compute good variable orderings. How these ideas can be used in decomposing a function either for representation as a set of OBDDs or for implementation in a cascode technology is outlined. A class of multioutput functions, which includes addition, whose members have particularly small OBDDs is characterized. >
TL;DR: An efficient method for the generation of all the 2/sup n/ sets of generalized Reed-Muller (GRM) coefficients for a Boolean function f(X) of n variables using the binary decision diagram (BDD) is presented.
Abstract: An efficient method for the generation of all the 2/sup n/ sets of generalized Reed-Muller (GRM) coefficients for a Boolean function f(X) of n variables using the binary decision diagram (BDD) is presented. The author describes the generation of RM coefficients from minterm values and relates them to the associated subfunctions. Examples are included to illustrate the procedure. >
TL;DR: The authors present various applications of Boolean unification to combinational logic synthesis, including redesign, multilevel logic minimization, and minimization of Boolean relations.
Abstract: The authors present various applications of Boolean unification to combinational logic synthesis. Three topics of combinational logic synthesis are discussed: redesign, multilevel logic minimization, and minimization of Boolean relations. All of these problems can be uniformly formalized as Boolean unification problems. Experimental results are also reported. >
TL;DR: A procedure to synthesise minimal 0th polarity Reed-Muller networks for incompletely specified Boolean functions is presented and a procedure that uses reduced representations of Boolean functions in the form of logical covers to synthesising Reed-muller Networks is presented.
Abstract: Reed-Muller canonical networks are known to be easily testable implementations of logical functions. We present a procedure to synthesise minimal 0th polarity Reed-Muller networks for incompletely specified Boolean functions. We also present a procedure that uses reduced representations of Boolean functions in the form of logical covers to synthesise Reed-Muller networks. The latter procedure avoids exponentially long minterm representations, and hence alleviates some of the difficulties in applying spectral synthesis procedures to large Boolean functions. Both of these procedures are suitable for automation.
TL;DR: It is shown that the observability don't cares (ODCs) for a node y/sub i/ in N' provide the maximum flexibility for implementing y/ Sub i/ and subsume the flexibility obtained for y/ sub i/in N even withDon't cares provided at each output.
Abstract: The observability relation O(x,z) or the Boolean relation provides a description of all the flexibility one has in implementing a Boolean network N. The authors represent and use this flexibility in a logic synthesis system by adding a single output node to the Boolean network N. The node function for the new node is O(x,z). The newly constructed network N' (called the observability network) has only one output and computes 1 for every input x. It is shown that the observability don't cares (ODCs) for a node y/sub i/ in N' provide the maximum flexibility for implementing y/sub i/ and subsume the flexibility obtained for y/sub i/ in N even with don't cares provided at each output. This gives rise to new methods for computing complete ODCs for N' and hence for N. >
TL;DR: This work generalizes an existing lower bound technique and combines it with restriction arguments to provide a lower bound ofn0.51 on the number of positions that have to be evaluated by any randomized α-β pruning algorithm computing the value of any two-person zero-sum game tree withn final positions.
Abstract: We consider the deterministic and the randomized decision tree complexities for Boolean functions, denotedDC(f) andRC(f), respectively. A major open problem is how smallRC(f) can be with respect toDC(f). It is well known thatRC(f)≥DC(f)
0.5 for every Boolean functionf (called “0.5-exponent”). On the other hand, some Boolean functionf is known to haveRC(f) = Θ(DC(f))0.753...) (or “0.753...-exponent”). It is not known whether there is a Boolean function with exponent smaller than 0.753... Likewise, no lower bound for arbitrary Boolean functions with exponent greater than 0.5 is known. Our result is a 0.51 lower bound on the exponent for everyread-once function. Read-once means that each input variable appears exactly once in the Boolean formula representing the function. To obtain this result we generalize an existing lower bound technique and combine it with restriction arguments. This result provides a lower bound ofn
0.51 on the number of positions that have to be evaluated by any randomized α-β pruning algorithm computing the value of any two-person zero-sum game tree withn final positions.
TL;DR: A simple, and easy-to-check, property of a symmetric boolean function is shown to imply a $4n - O(1)$ lower bound on the circuit complexity of the function over $U_2 = B_2 - \oplus, \equiv \}$, the basis of unate dyadic boolean functions.
Abstract: A simple, and easy-to-check, property of a symmetric boolean function is shown to imply a $4n - O(1)$ lower bound on the circuit complexity of the function over $U_2 = B_2 - \{ \oplus , \equiv \}$, the basis of unate dyadic boolean functions. Among the functions to which this lower bound applies are the modular functions ${\operatorname{MOD}}_k (n)$ for any fixed $k \geqq 3$ (${\operatorname{MOD}}_k (n)$ is the function which returns 1 if and only if $(\sum x_i )\bmod k = 0$). Finally, a $5n$ upper bound is obtained on the circuit complexity over $U_2 $ of the function ${\operatorname{MOD}}_4 (n)$.
TL;DR: A novel representation called an equivalence class characterization function is defined that can implicitly represent all equivalence classes with a compact characteristic function that will have at most n outputs and is described based on binary decision diagrams.
Abstract: A novel representation called an equivalence class characterization function is defined. It can implicitly represent all equivalence classes with a compact characteristic function that will have at most n outputs. Using binary decision diagrams (BDDs) and the concept of the equivalence class characterization function, very large problem instances can be represented. For manipulating equivalence classes efficiently, a Boolean operator called a compatible projection operator is proposed. Conceptually, the compatible projection operator is used to uniquely select a single element from each equivalence class to characterize the class. In manipulating equivalence classes, the compatible projection operator is used to implicitly derive an encoding function from the equivalence relation that encodes the equivalence class information symbolically. An efficient implementation is described based on BDDs that is applied to very large problem instances. >