The Boolean Nearest Neighbor (BNN) representation of Boolean functions was recently introduced by Hajnal, Liu and Turan. A BNN representation of f is a pair (P,N) of sets of Boolean vectors (called positive and negative prototypes) where f(x)=1 for every positive prototype x ∈ P, f(x)=0 for all every negative prototype x ∈ N, and the value f(x) for x ∉P ∪ N is determined by the type of the closest prototype. The main aim of this paper is to determine the position of the BNN language in the Knowledge Compilation Map (KCM). To this end, we derive results which compare the succinctness of the BNN language to several standard languages from KCM, and determine the complexity status of most standard queries and transformations for BNN inputs.

We consider distributed approval voting schemes. Each voter i ∈ I has α _i cards that (s)he distributes among the candidates a ∈ A as a measure of approval. One (or several) candidate(s) who received the maximum number of cards is (are) elected. We provide polynomial algorithms to recognize voting forms and voting correspondences generated by such voting schemes in cases when either the number of candidates or the number of voters is equal to 2. We prove that for two voters, if α _2≥α _1-2≥ 0 then the unique voting correspondence has distinct rows. We also characterize voting forms with distinct rows.

A switch-list representation (SLR) of a Boolean function is a compressed truth table representation of a Boolean function in which only (i) the function value of the first row in the truth table and (ii) a list of switches are stored. A switch is a Boolean vector whose function value differs from the value of the preceding Boolean vector in the truth table. The paper Čepek and Chromý (JAIR 2020) systematically studies the properties of SLRs and among other results gives polynomial-time algorithms for all standard queries investigated in the Knowledge Compilation Map introduced in Darwiche and Marquis (JAIR 2002). These queries include consistency check, validity check, clausal entailment check, implicant check, equivalence check, sentential entailment check, model counting, and model enumeration. The most difficult query supported in polynomial time by the smallest number of representation languages considered in the Knowledge Compilation Map is the sentential entailment check (of which the equivalence check is a special case). This query can be answered in polynomial time for SLRs, as shown in Čepek and Chromý (JAIR 2020). However, the query-answering algorithm is an indirect one: it first compiles both input SLRs into OBDDs (changing the order of variables for one of them if necessary) and then runs the sentential entailment check on the constructed OBDDs (both respecting the same order of variables) using an algorithm from the monograph by Wegener (2000). In this paper we present algorithms that answer both the equivalence and the sentential entailment query directly by manipulating the input SLRs (hence eliminating the compilation step into OBDD), which in both cases improves the time complexity of answering the query by a factor of n for input SLRs on n variables.

Horn functions form a subclass of Boolean functions and appear in many different areas of computer science and mathematics as a general tool to describe implications and dependencies. Finding minimum sized representations for such functions with respect to most commonly used measures is a computationally hard problem that remains hard even for the important subclass of key Horn functions. In this paper we provide logarithmic factor approximation algorithms for key Horn functions with respect to all measures studied in the literature for which the problem is known to be hard.

A switch-list representation (SLR) of a Boolean function is a compressed truth table representation of a Boolean function in which only the function value of the first row in the truth table and an ordered list of switches are stored. A switch is a Boolean vector whose function value differs from the value of the preceding Boolean vector in the truth table. In this short paper we outline scenarios under which SLRs constitute a better representation language than standard representation languages such as CNFs and OBDDs. Furthermore, we outline a possible approach to constructing a compiler from CNFs to SLRs which is a necessary tool for verifying practical usefulness of SLRs.

Given a relational database, a key is a set of attributes such that a value assignment to this set uniquely determines the values of all other attributes. The database uniquely defines a pure Horn function h, representing the functional dependencies. If the knowledge of the attribute values in set A determines the value for attribute v, then A→v is an implicate of h. If K is a key of the database, then K→v is an implicate of h for all attributes v. Keys of small sizes play a crucial role in various problems. We present structural and complexity results on the set of minimal keys of pure Horn functions. We characterize Sperner hypergraphs for which there is a unique pure Horn function with the given hypergraph as the set of minimal keys. Furthermore, we show that recognizing such hypergraphs is co-NP-complete already when every hyperedge has size two. On the positive side, we identify several classes of graphs for which the recognition problem can be decided in polynomial time. We also present an algorithm that generates the minimal keys of a pure Horn function with polynomial delay, improving on earlier results. By establishing a connection between keys and target sets, our approach can be used to generate all minimal target sets with polynomial delay when the thresholds are bounded by a constant. As a byproduct, our proof shows that the Minimum Key problem is at least as hard as the Minimum Target Set Selection problem with bounded thresholds.

In this paper we study the recently introduced switch-list representations (SLRs) of Boolean functions. An SLR is a compressed truth table representation of a Boolean function: we only store the function value of the first row, and a list of switches (Boolean vectors whose function value differs from the value of the preceding vector). The paper (Čepek and Chromý 2020) systematically studies the properties of SLRs and among other results gives polynomial time algorithms for all standard queries investigated in the Knowledge Compilation Map (Darwiche and Marquis 2002). In particular, the equivalence query (EQ) is implemented in (Čepek and Chromý 2020) by first compiling both input SLRs into OBDDs and then running the EQ query on the constructed OBDDs. In this short note we present an algorithm that answers the EQ query directly by manipulating the input SLRs (hence eliminating the compilation step into OBDD) which improves the time complexity of the procedure.

Given a CNF formula $\Phi$ with clauses $C_1,\ldots,C_m$ and variables $V=\{x_1,\ldots,x_n\}$, a truth assignment $a:V\rightarrow\{0,1\}$ of $\Phi$ leads to a clause sequence $\sigma_\Phi(a)=(C_1(a),\ldots,C_m(a))\in\{0,1\}^m$ where $C_i(a) = 1$ if clause $C_i$ evaluates to $1$ under assignment $a$, otherwise $C_i(a) = 0$. The set of all possible clause sequences carries a lot of information on the formula, e.g. SAT, MAX-SAT and MIN-SAT can be encoded in terms of finding a clause sequence with extremal properties. We consider a problem posed at Dagstuhl Seminar 19211 "Enumeration in Data Management" (2019) about the generation of all possible clause sequences of a given CNF with bounded dimension. We prove that the problem can be solved in incremental polynomial time. We further give an algorithm with polynomial delay for the class of tractable CNF formulas. We also consider the generation of maximal and minimal clause sequences, and show that generating maximal clause sequences is NP-hard, while minimal clause sequences can be generated with polynomial delay.

Given a truth table representation of a Boolean function f the switch-list (SL) representation of f consists of the function value f(0) at the all-zero vector and the list of all Boolean vectors from the truth table of f which have a different function value then the preceding vector. The main result of this paper is a polynomial time compilation algorithm from a SL representation of a given function f to an Ordered Binary Decision Diagram (OBDD) representation of f where the output OBDD respects some prescribed order of variables possibly different than the input order used by the SL representation of f . Furthermore we provide a lower bound construction which shows that the presented compilation algorithm yields an asymptotically optimal size OBDD of f respecting the prescribed output order of variables.

In this paper we focus on a less usual way to represent Boolean functions, namely on representations by switch-lists. Given a truth table representation of a Boolean function f the switch-list representation (SLR) of f is a list of Boolean vectors from the truth table which have a different function value than the preceding Boolean vector in the truth table. The main aim of this paper is to include the language SL of all SLR in the Knowledge Compilation Map [Darwiche and Marquis, 2002] and to argue that SL may in certain situations constitute a reasonable choice for a target language in knowledge compilation. First we compare SL with a number of standard representation languages (such as CNF, DNF, and OBDD) with respect to their relative succinctness. As a by-product of this analysis we also give a short proof of a long standing open question from [Darwiche and Marquis, 2002], namely the incomparability of MODS (models) and PI (prime implicates) languages. Next we analyze which standard transformations and queries (those considered in [Darwiche and Marquis, 2002]) can be performed in poly-time with respect to the size of the input SLR. We show that this collection is quite broad and the combination of poly-time transformations and queries is quite unique.

In this paper, we focus on a less usual way to represent Boolean functions, namely on representations by switch-lists, which are closely related to interval representations. Given a truth table representation of a Boolean function f the switch-list representation of f is a list of Boolean vectors from the truth table which have a different function value than the preceding Boolean vector in the truth table. The main aim of this paper is to include this type of representation in the Knowledge Compilation Map by Darwiche and Marquis and to argue that switch-lists may in certain situations constitute a reasonable choice for a target language in knowledge compilation. First, we compare switch-list representations with a number of standard representations (such as CNF, DNF, and OBDD) with respect to their relative succinctness. As a by-product of this analysis, we also give a short proof of a long-standing open question proposed by Darwiche and Marquis, namely the incomparability of MODS (models) and PI (prime implicates) representations. Next, using the succinctness result between switch-lists and OBDDs, we develop a polynomial time compilation algorithm from switch-lists to OBDDs. Finally, we analyze which standard transformations and queries (those considered by Darwiche and Marquis) can be performed in polynomial time with respect to the size of the input if the input knowledge is represented by a switch-list. We show that this collection is very broad and the combination of polynomial time transformations and queries is quite unique. Some of the queries can be answered directly using the switch-list input, others require a compilation of the input to OBDD representations which are then used to answer the queries.

A discrete function of n variables is a mapping g : X 1 × … × X n → A, where X 1 , … , X n, and A are arbitrary finite sets. Function g is called separable if there exist n functions g i : X i → A for i = 1 , … , n, such that for every input x 1 , … , x n the function g ( x 1 , … , x n ) takes one of the values g 1 ( x 1 ) , … , g n ( x n ). Given a discrete function g, it is an interesting problem to ask whether g is separable or not. Although this seems to be a very basic problem concerning discrete functions, the complexity of recognition of separable discrete functions of n variables is known only for n = 2. In this paper we will show that a slightly more general recognition problem, when g is not fully but only partially defined, is NP-complete for n ≥ 3. We will then use this result to show that the recognition of fully defined separable discrete functions is NP-complete for n ≥ 4. The general recognition problem contains the above mentioned special case for n = 2. This case is well-studied in the context of game theory, where (separable) discrete functions of n variables are referred to as (assignable) n-person game forms. There is a known sufficient condition for assignability (separability) of two-person game forms (discrete functions of two variables) called (weak) total tightness of a game form. This property can be tested in polynomial time, and can be easily generalized both to higher dimension and to partially defined functions. We will prove in this paper that weak total tightness implies separability for (partially defined) discrete functions of n variables for any n, thus generalizing the above result known for n = 2. Our proof is constructive. Using a graph-based discrete algorithm we show how for a given weakly totally tight (partially defined) discrete function g of n variables one can construct separating functions g 1 , … , g n in polynomial time with respect to the size of the input function.

A pure Horn CNF is minimal if no shorter pure Horn CNF representing the same function exists, where the CNF length may mean several different things, e.g. the number of clauses, or the total number of literals (sum of clause lengths), or the number of distinct bodies (source sets). The corresponding minimization problems (a different problem for each measure of the CNF size) appear not only in the Boolean context, but also as problems on directed hypergraphs or problems on closure systems. While minimizing the number of clauses or the total number of literals is computationally very hard, minimizing the number of distinct bodies is polynomial time solvable. There are several algorithms in the literature solving this task. In this paper we provide a structural result for this body minimization problem. We develop a lower bound for the number of bodies in any CNF representing the same Boolean function as the input CNF, and then prove a strong duality result showing that such a lower bound is always tight. This in turn gives a simple sufficient condition for body minimality of a pure Horn CNF, yielding a conceptually simpler minimization algorithm compared to the existing ones, which matches the time complexity of the fastest currently known algorithm.

A Boolean formula in conjunctive normal form (CNF) is called matched if the system of sets of variables which appear in individual clauses has a system of distinct representatives. We present here two results for matched CNFs: The first result is a shorter and simpler proof of the fact that Boolean minimization remains complete for the second level of polynomial hierarchy even if the input is restricted to matched CNFs. The second result is structural — we show that if a Boolean function f admits a representation by a matched CNF then every clause minimum CNF representation of f is matched.

Introduction A Boolean function of n variables is a mapping from {0, 1} to {0, 1}. Boolean functions naturally appear in many areas of mathematics and computer science and constitute a key concept in complexity theory. In this paper we shall study an important problem connected to Boolean functions, a so called Boolean minimization problem, which aims at finding a shortest possible representation of a given Boolean function. The formal statement of the Boolean minimization problem (BM) of course depends on how the input function is represented, and how the size of the output is measured. One of the most common representations of Boolean functions are conjunctive normal forms (CNFs). There are two usual ways how to measure the size of a CNF: the number of clauses and the total number of literals (sum of clause lengths). It is easy to see that BM is NP-hard if both input and output is a CNF (for both measures of the size of the output CNF). This is an easy consequence of the fact that BM contains the CNF satisfiability problem (SAT) as its special case (an unsatisfiable formula can be trivially recognized from its shortest CNF representation). In fact, BM was shown to be in this case probably harder than SAT: while SAT is NP-complete (i.e. Σp1-complete (Cook 1971)), BM is Σp2-complete (Umans 2001) (see also the review paper (Umans, Villa, and Sangiovanni-Vincentelli 2006) for related results). It was also shown that BM is Σp2-complete when considering Boolean functions represented by general formulas of constant depth as both the input and output for BM (Buchfuhrer and Umans 2011). Due to the above intractability result, it is reasonable to

In this short note we will present a less common way how to represent a Boolean function, namely a representation by switch-list. There are two problems connected to such representation: (1) a knowledge compilation problem, i.e. a problem of transforming a given representation of a Boolean function (e.g. a DNF, CNF, BDD ...) into a switch-listl representation, and (2) a knowledge compression problem, i.e. a problem of finding the most compact switch-list representation among those which represent the same function. We will summarize known results about these two problems and present a new one about the compilation

A Boolean formula in conjunctive normal form (CNF) is called matched if the system of sets of variables which appear in individual clauses has a system of distinct representatives. Each matched CNF is trivially satisfiable (each clause can be satisfied by its representative variable). Another property which is easy to see, is that the class of matched CNFs is not closed under partial assignment of truth values to variables. This latter property leads to a fact (proved here) that given two matched CNFs it is co-NP complete to decide whether they are logically equivalent. The construction in this proof leads to another result: a much shorter and simpler proof of Σ2p-completeness of Boolean minimization for matched CNFs. The main result of this paper deals with the structure of clause minimum CNFs. We prove here that if a Boolean function f admits a representation by a matched CNF then every clause minimum CNF representation of f is matched.

It is a wellknown fact that the satisfiability problem (SAT) for Boolean formulas in a conjunctive normal form (CNF) is NP complete, i.e. Σ1 complete. It is also known that the decision version of Boolean minimization for CNF inputs is Σ2 complete. On the other hand there are several subclasses of CNFs (e.g. Horn CNFs) for which SAT is known to be in P = Σ0 while the minimization problem is Σ1 complete. Thus, for both the general case and the above mentioned subclasses the gap between the complexity of SAT and minimization is exactly one level in the polynomial hierarchy. There are also some subclasses (e.g. quadratic CNFs) for which there is no gap because both SAT and minimization are in P = Σ0. In this short note we shall systematically study different classes of Boolean functions with respect to the size of the mentioned gap and show that there also exist classes for which the gap between the complexity of SAT and minimization is the maximum possible (two levels in the polynomial hierarchy). To this end we shall recall a recent result showing that the minimization of the so called matched CNFs is Σ2 complete.

A CNF is minimal if no shorter CNF representing the same function exists, where by CNF length we mean either the number of clauses or the total number of literals (sum of clause lengths). In this paper we develop a decomposition approach that can be in certain situations applied to a CNF formula when proving its minimality. We give two examples in which this decomposition approach is used. Both examples deal with pure Horn minimization, a problem defined as follows: given a pure Horn CNF, construct a logically equivalent pure Horn CNF which is the shortest possible (either w.r.t. the number of clauses or w.r.t. the total number of literals). Both presented examples give alternative proofs of known complexity results for pure Horn minimization.

Knowledge compilation is a process of adding more information to a knowledge base in order to make it easier to deduce facts from the compiled base than from the original one. One type of knowledge compilation occurs when the knowledge in question is represented by a Boolean formula in conjunctive normal form (CNF). The goal of knowledge compilation in this case is to add clauses to the input CNF until a logically equivalent propagation complete CNF is obtained. A CNF is called propagation complete if after any partial substitution of truth values all logically entailed literals can be inferred from the resulting CNF formula by unit propagation. The key to this type of knowledge compilation is the ability to generate so-called empowering clauses. A clause is empowering for a CNF if it is an implicate and for some partial substitution of truth values it enlarges the set of entailed literals inferable by unit propagation.