Abstract
This paper is devoted to the study of complexity of finding a special covering for a set, as well as to obtaining some important applications of special decomposition. We formulate the problem of existence of a special covering as a decision problem. To determine the complexity class in which this problem is located, we study the relationship between this problem and the Boolean satisfiability problem, treating them as formal languages. We prove that these problems are polynomially equivalent, which means that the problem of existence of a special covering for a set is an -complete problem. In this article we also introduce a new concept ‘Replaceable Subsets’. The properties of such subsets are used to fill in the missing elements needed to obtain a special set covering. It is proved that when searching for missing elements to fill a special covering, the order in which these elements are considered does not matter. This result is of great importance in the search for satisfiability of Boolean functions.
Keywords
Special Decomposition, Boolean Satisfiability, Equivalence of Problems
1. Introduction
In
the concept of a special decomposition of a set and the concept of special covering for a set under such a decomposition are introduced. These concepts have proven to be flexible and easy to use. They can be used in the field of Boolean functions to study important problems, including the satisfiability problem.
In a general sense, the relationship between the complexity classes of various decision problems
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
| [4] | Cook, S. A., The complexity of theorem - proving procedures. In Conference Record of Third Annual ACM Symposium on Theory of Computing (1971), 151–158. |
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
| [12] | (L. A. Levin, “Universal problems of full search”, Probl. Inf. Transm., 9: 3 (1973), 265–266). |
[2, 4, 11, 12]
still remains open. However, with the formation of the concept of
NP -complete problem, many fundamental studies with significant results appear from time to time. In particular, various complexity classes based on time and space complexity, as well as the relations between them, are widely studied in
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
| [3] | Armin Biere, Marijn Heule, Hans van Maaren and Toby Walsh, Handbook of Satisfiability, IOS Press, 2008. |
| [6] | Peter G´acs, Boston University and L´aszl´o Lov´asz, Yale University, Complexity of Algorithms Lecture Notes, Spring 1999. |
| [15] | Daniel Pierre Bovet and Pierluigi Crescenzi. Introduction to the Theory of Complexity. Prentice-Hall, New York, 1993. |
| [22] | Sipser Michael, Introduction to the Theory of Computation, 2012, Cengage Learning. |
[2, 3, 6, 15, 22]
.
A well-known theoretical study is Schaefer’s result
| [20] | Thomas J. Schaefer, The complexity of Satisfiability Problems, 1978. Department of Mathematics University of California, Berkeley, California 94720. |
[20]
, where specific classes of Boolean formulas with certain restrictions are considered. If the formula belongs to one of these classes, then it is decidable in polynomial time. In fact, Schaefer’s dichotomy theorem shows that, depending on the restrictions in a propositional formula, the problem either belongs to the class
P or is
NP-complete
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
| [4] | Cook, S. A., The complexity of theorem - proving procedures. In Conference Record of Third Annual ACM Symposium on Theory of Computing (1971), 151–158. |
[2, 4]
. Also, if
P ≠
NP, then the formula is in
P, if it satisfies certain conditions. In fact, Schaefer considers only the complexity classes
P and
NP.
Later, Schaefer’s result was refined and extended
| [1] | Allender, E., Bauland, M., Immerman, N., Schnoor, H., Vollmer, H. The complexity of satisfiability problems: Refining Schaefer’s theorem. J. Comput. Syst. Sci. 75(4), 245–254 (2009). |
[1]
. It is shown that there is also another classification when considering another approach, since there are different problems in
P with completely different complexity, which leads to the existence of different complexity classes. As for Schaefer’s classification, unfortunately, some problems arise in determining whether a formula belongs to a given class. It is not always “easy” to check whether a given formula belongs to a given class. A recognition criteria related to this problem is formulated in
| [8] | S. A. Gizunov and V. A. Nosov, Recognition complexity for Sheffer classes, Mosc. Univ. Math. Bull. 51, no. 4, pp. 86–88, 1996. UDC 519.716. |
[8]
. In addition, the issues of approximation of a function to Schaefer’s classes by fixing some variables of the function are investigated in
| [17] | E. A. Potseluevskaya, Approximation of Boolean functions to Schaefer’s classes. Journal of Mathematical Sciences, June 2012, vol 183. |
[17]
. Also, an estimate of the complexity of such an algorithm is obtained.
An important result was also obtained in
: it turns out that a number of
NP-complete problems remain
NP-complete even with a significant restriction on their scope.
We assume that if there exist conditions that completely determine the complexity class of a problem, then the justification of these conditions as applied to a specific problem will most likely be of an algorithmic nature.
In this article we investigate the complexity of finding a special covering for a set. By formulating this problem and the Boolean satisfiability problem as formal languages
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
[2]
, we prove that these problems are polynomially reducible
| [4] | Cook, S. A., The complexity of theorem - proving procedures. In Conference Record of Third Annual ACM Symposium on Theory of Computing (1971), 151–158. |
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
| [12] | (L. A. Levin, “Universal problems of full search”, Probl. Inf. Transm., 9: 3 (1973), 265–266). |
[4, 11, 12]
to each other. This means that using the special decompositions, we obtain results for Boolean functions.
One of the important contributions of this article is connected with exploring some of the challenges that arise when searching for a special covering for a set, or equivalently, when searching for satisfiability of a Boolean function.
These results we obtain by introducing new concept of ‘Replaceable Subsets’.
The essence of this concept is by means of permutation of components of some ordered pairs of the special decomposition, collect all elements in some of the domains of the decomposition. For each element, the corresponding ordered pairs are considered separately.
We prove that when searching for missing elements to fill a special covering for the set, the order in which these elements are considered does not matter.
In addition, another result was obtained concerning Boolean functions. It is proven that any I-transformation of a special decomposition of the set of clauses of a function partitions this set into two satisfiable subsets. These results are of great importance in the search for satisfiability of Boolean functions represented in conjunctive normal form.
Another result that may have significant implications for Boolean functions as well. We prove that any Boolean function represented in conjunctive normal form is satisfiable if and only if it can be transformed, according to certain rules, into a function in which every clause contains a negative literal or every clause contains positive literal. These clauses have some similarity with Horn clauses
| [5] | Yves Crama, Peter L. Hammer, Boolean Functions. Theory, Algorithms, and Applications, 2011. |
| [9] | A. Horn, On sentences which are true of direct unions of algebras. Journal of Symbolic Logic. 16(1): 14–21, 1951.
https://doi.org/10.2307/2268661 JSTOR 2268661. S2CID 42534337. |
[5, 9]
, but they are not always the same.
Note also, that the terminology used in relation to the well-known concepts of set theory corresponds to the terminology in
| [10] | Thomas Jech, Set Theory, The Third Millennium Edition, 2003. |
| [16] | Charles C. Pinter, A Book of Set Theory, 2014. |
| [19] | Kenneth H. Rosen, Discrete Mathematics and its Applications, seventh edition, 2012. |
| [21] | Edward R. Scheinerman, Mathematics: A Discrete Introduction, Third Edition 2013. |
[10, 16, 19, 21]
.
2. Basic Concepts
Let's recall some definitions, terms and notations from
, that we will rely on. The sets we will consider are assumed to be ordered unless otherwise stated.
Let the nonempty set S {, ,..., } be given. Let also for some natural number ,
(,), (,),..., (,)
be arbitrary ordered pairs of arbitrary subsets of the set .
We use the notation for an arbitrarily ordered set of these ordered pairs:
S= {(,), (,),..., (,)}.
The Boolean values and , for ∈ [1, ], are used to denote superscripts of subsets:
= 0 if= 1, and= 1 if= 0.
The tuple of superscripts (,..., ) of subsets is also called a Boolean tuple.
Definition 2.1. The set will be called a special decomposition of the set S, if
1) ∀ [1, ] )= ∅,
2) ∀ [1, ] ( ∅),
3) = S.
Definition 2.2. Let the set S be a special decomposition of the set S.
For any Boolean tuple (, ,..., ) the ordered set
S ={,,...,}
will be called a special covering for the set under the special decomposition S, if
Note that for any [1, ] the subsets and cannot simultaneously belong to the special covering, but one of them exactly belongs.
Let for some natural number ,
S = {(,),..., (,)}
be an ordered set of arbitrary ordered pairs of subsets of the set S.
The permutation of the components of some ordered pairs of the set , let them be
{,,...,,)}⊆,
if the order of pairs in does not change, will be called an I-transformation of the set S. The resulting set is denoted as ,...,() or simply as I(S):
I(S) =,,..., (,)}.
The ordered pairs included in this decomposition are defined as follows:
(, ) = (, ), if the components of the i-th pair are not displaced,
(, ) = (, ), if the components of the i-th pair are displaced.
Obviously, the transition from the set I(S) to the set S is also an I-transformation.
Recall that, according to Lemma 1.3 in
, for any special decomposition of the set S, any
-transformation preserve the possibility of being a special decomposition of the set
and having a special covering for
under such a decomposition.
Thus, with the same pairs of subsets and for any Boolean tuple (, ,..., ) in generally the special decomposition looks like
S=,,..., (,)}.
We will also use some terms introduced in
to distinguish the subsets included in ordered pairs of a special decomposition according to the order of their location in these pairs.
The subsets ,..., are called the subsets of 0-domain,
The subsets ,..., are called the subsets of 1-domain.
If the ordered pair (, ) S, then the subset belongs to the -domain and the subset belongs to the 1-domain. If the components of this ordered pair are permuted, then the subset becomes a subset of the -domain, and the subset becomes a subset of the -domain.
In addition, for any {0, 1}, we will use the following notations:
=and=.
= {,...,} and= {,...,}.
The set will be called a set of -components or -domain of the decomposition .
(,..., )s is the set obtained by replacing the subsets ,..., with the subsets ,..., , respectively, in the set .
(,..., ) will be called a set of -components of the ordered pairs of decomposition (,..., )I(S).
One of the main goals of the concept special decomposition is to search for a special covering for a given set under a given special decomposition.
With the introduction of the concept of a special decomposition of a set, a problem naturally arises. We will call it a problem of existence of a special covering for a set. Let’s formulate it.
Given a special decomposition of a set. If there exists a special covering for this set under the given special decomposition?
Next, we will study the relationship between this problem and the Boolean Satisfiability Problem.
3. Special Decompositions and Boolean Functions as Formal Languages
Let
(
,...,
) be a Boolean function represented in conjunctive normal form (CNF)
| [5] | Yves Crama, Peter L. Hammer, Boolean Functions. Theory, Algorithms, and Applications, 2011. |
| [19] | Kenneth H. Rosen, Discrete Mathematics and its Applications, seventh edition, 2012. |
[5, 19]
with
clauses. It is assumed that the clauses of the function are numbered 1,...,
, so we will use the notation
for the
-th clause of the function,
∈ [1,
]. That is,
The clause of the literals ,..., is considered with the following conditions:
=..., where ,..., , ∈[1, ], ∈{0,1}.
In addition, for any i ∈ [1, ], = and = .
For simplicity, we assume that no variable and its negation are included in the same clause simultaneously. Obviously, it does not limit the set of functions being considered.
The Boolean Satisfiability Problem or satCNF problem is the problem of determining whether a given Boolean function (,..., ) represented in conjunctive normal form is satisfiable, that is, whether there exists a Boolean tuple (,...,) such that (,...,) =1.
Our goal is to show that the problem of finding a special covering for a set given a special decomposition of this set is an NP-complete problem
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
[11]
. To do this, we first form concrete formal languages
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
[2, 11]
over some alphabets. In general, we will use the following alphabet:
= {0, 1,,,⋆, ▫,,𝜀}.
However, in some individual cases, for convenience, we use the alphabets
= {0, 1,,,⋆}⊆and= {0, 1,⋆, ▫,,𝜀}⊆.
The expressions will be represented as strings over these alphabets.
The length of a string is considered t
o be the number of symbols included in it | [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
[2]
.
The symbols 0, 1, , will be used to form different literals. The literals will be used with the following meaning:
=() =and=() =.
We will use also the notation meaning that {0,1}.
For simplicity we assume that () is a binary expression of the number . It will be called an index of the literal.
Obviously, the number of variables of the function will also be the number of literals with pairwise different indices included in the clauses of the function.
Similarly, the symbols , 0, 1 will be used to form expressions such as = (), for designation elements of sets, where() is the binary expression of the number .
However, when assigning literals and set elements, we will often use subscripts.
The symbols '⋆' and '▫' are separating symbols. And ‘𝜀’ is a special symbol, which will mean the empty string corresponding to the empty set.
Let’s for any natural numbers and define the languages () and CNF(, ) over the alphabet
For any Boolean tuple (,..., ):
CLAUSE () = {⟨ ⟩ / {,..., } is a set of literals such that (k, ∈ [1, ]) & (, if r l)}.
It is important to note, that the language CLAUSE() does not contain an empty string. Also, it does not contain a string that includes any variable and its negation simultaneously.
We will say that the string
⟨⟩ corresponds to the set {, ,..., }
as well as we will say that the string is formed by the clause.
Let for different indices denote different strings included in the language CLAUSE(). Then, we define the language CNF(, ) as follows:
CNF(, ) = {⟨ ⋆ ⋆... ⋆ ⟩ / ∀ ∈ [1, ], CLAUSE()}.
Let's now consider the alphabet = {0, 1, ⋆, ▫, , 𝜀}. Using the symbols , 0 and 1, we compose expressions over the to denote elements of an arbitrary set
Since the empty subset plays an important role in the special decomposition, we need a symbol for forming the strings corresponding to the pairs of subsets with an empty component. That is, we will use some symbol to form strings corresponding to the ordered pairs of subsets, such as (M, ∅) or (∅, M) for some nonempty subset M. Let 𝜀 ∈ Σ be such a symbol.
Now for a natural number we define the languages (), () and () over the alphabet as follows:
SUB() = {⟨ ... ⟩/ (k ∈ [1, ]) & (, if )}.
() = {𝜀} SUB().
Note that the language () does not contain an empty string.
We say that the string M = ⟨ ... ⟩ corresponds to the set {M } = {, ,..., } or the string M is formed by the set {M }.
For any set N, we denote by ⟨N ⟩ the string that is formed by the set N. This means that for a set of at most elements ⟨⟩ ().
With such designation we define the language PAIR().
PAIR () = {⟨M ▫ N⟩ / (M ()) & (N ()) & ({M} ⋂ {N } = ∅) & (M N )}
Note that for any strings M () and N (), we consider the string ⟨M ▫ N ⟩ to be an ordered pair of strings M and N. Also, for any natural number ,
⟨M ▫ 𝜀⟩ PAIR() and ⟨𝜀 ▫ N⟩ PAIR()
only with {M } ∅ and {N } ∅.
For convenience, we will use subscripts and superscripts to distinguish between the notation of the substrings included in (). That is, for some natural number , we will use the notation ⟨ ▫ ⟩ for the string ⟨M ▫ N ⟩∈ PAIR(). Then, for any natural numbers and , we define the language (, ) over the alphabet :
d(, ) = ⟨ ▫ ⋆... ⋆ ▫ ⟩ ̸ ∀ ∈ [1, ] ⟨ ▫ ⟩ PAIR(), and is the number of elements with pairwise different indices in all subsets}.
The evidence for the following statements is obvious.
Proposition 3.1. For any natural numbers and , holds the following:
1) if ⟨... ⟩ CLAUSE(), and the set {,..., } is any permutation of the set of literals {,..., }, then also ⟨,..., ⟩ CLAUSE(),
2) if ⟨ ⋆... ⋆ ⟩ CNF(, ), and the set {,..., } is any permutation of the set {,..., }, then ⟨⋆... ⋆ ⟩ CNF(, ).
3) ⟨⋆... ⋆ ⟩ CNF(, ) if and only if the clauses corresponding to the strings designated as , ,..., form a certain function , represented in CNF with variables and with clauses.
4) if the string ⟨... ⟩ ∈ SUB() and the set {,..., } is any permutation of the set {, ..., }, then ⟨... ⟩ ∈ SUB().
5) if ⟨M ▫ N⟩ ∈ PAIR() then ⟨N ▫ M ⟩ ∈ PAIR(),
6) if ⟨ ▫ ⋆... ⋆ ▫ ⟩ ∈ d(, ) and the set , ),..., (, )} is any permutation of the set {(, ),..., (, )} then
⟨ ▫ ⋆... ⋆ ▫ ⟩ ∈ d(, )
7) ⟨ ▫ ⋆... ⋆ ▫ ⟩ d(, ) if and only if the set = consists of elements and the ordered set of ordered pairs
{({}, {}),..., ({}, {})}, is a special decomposition of the set S, where ⟨⟩ corresponds to the set {} for ∈ [1, ].
Thus, strings of different languages have some basic properties of the corresponding sets.
Sometimes, if it does not lead to an ambiguity, we will use the notation M instead of {M} for the set corresponding to the string ⟨M ⟩.
To estimate the complexity of recognizing these languages, we turn to Turing machines using definitions in
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
| [14] | J. Donald Monk, Mathematical Logic. Springer-Verlag, 1976. |
[2, 11, 14]
. Note that we need to specify the input data for any language. Actually, we have defined these languages for any natural numbers, and the membership of strings to languages depends on these numbers. So, for any language, we compare the corresponding parameters with these numbers. For any string
we will use |
| to denote the number of symbols included in it.
Proposition 3.2. For any natural number and , there exist Turing machines , , , and that recognize the languages CLAUSE(), CNF(, ), SUB(), PAIR(), and d(, ), respectively, in polynomial time.
Proof. (i) Let
be a string over the alphabet Σ. We assume that Σ is also an alphabet for each simulated Turing machine. It is convenient and easy simulate a 4-tape Turing machines with an input tape, two work tapes and an output tape
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
[2]
.
Let’s describe the general workflow of . Receiving the string , does:
(i.1) checks if starts with one of the symbols or ,
(i.2) checks whether a binary code follows any occurrence of the symbol or .
(i.3) checks if one of the characters or , or the special symbol "end of string", follows the binary code. Meanwhile, if encounters an "end of string" symbol, it stops.
(i.4) checks whether the index of current literal is less than or equal to .
(i.5) checks, whether the index of the current literal differs from the indices of other literals included in the string.
If any of the points (i.1) - (i.5) has a negative answer, rejects the string, otherwise it continues to work until it has considered all pairs.
It is easy to see that with the described workflow, for any natural number , accepts only the strings belonging to the language CLAUSE() and rejects all other strings.
Obviously, the total number of operations required to perform the points (i.1) - (i.3), does not exceed the number || for some constant . Consider the points (i.4) and (i.5):
(i.4) to compare the literal indices with the number , records the number on the first work tape, the index of the current literal on the second work tape, and does the following:
1) if the index length is greater than the length of n’s record, then rejects the string ,
2) if the length of index is less than the length of n’s record, then records the next literal index on the second work tape and continues working,
3) if the lengths are equal, runs over both records on work tapes and compares corresponding binary digits with the same orders in these records. If, in the same order, 0 occurs on the first tape, and 1 on the second tape, rejects the string , otherwise continues working.
Thus, records each index on the second tape, compares its length with the ’s length and compares its digits with n’s digits. So, it needs no more than || operations for some constant .
(i.5) let the condition (i.1) - (i.4) be satisfied. This means that the string has the form
and will check if the binary numbers ,..., are pairwise distinct. It is easy to notice that
For the point (i.5) considers all pairs of literal indices looking for a pair of literals with the same indices: = . So, sequentially records the pairs on work tapes, runs over both records and compares corresponding binary digits in the same orders in these records. If a pair of different digits occurs in the current order or the lengths of records are different, moves on to comparing other pairs of indices, otherwise it rejects the string .
Obviously, requires no more than c min(||, ||) operations for some constant c, to compare the pair of indices and .
It is also easy to prove that the total number of comparison operations of all pairs of literal indices included in the string does not exceed the number c for some constant c.
(ii) Let’s now estimate the complexity of recognizing the language CNF(, ) for any natural numbers and . We describe the general workflow of Turing machine , that accepts the string , if ∈ CNF(, ) and rejects it otherwise. Receiving the string , does:
(ii.1) checks if the number of occurrences of the symbol ‘⋆’ is equal to ( – 1),
(ii.2) checks whether any occurrence of the character "⋆" in the string is located between a binary digit and a literal.
(ii.3) checks whether any substring is one of the following positions in the string :
1) between the start and the symbol "⋆",
2) between two symbols "⋆",
3) between the symbol "⋆" and the symbol ‘end of string’, and does not contain the symbol "⋆", is belongs to the language CLAUSE().
If any of the points (ii.1) - (ii.3) has a negative answer, rejects the string, otherwise it accepts the string . It is easy to see that with the described workflow, for any natural number and , accepts only the strings belonging to the language CNF(, ) and rejects all other strings.
Obviously, the total number of operations required to perform the points (ii.1) and (ii.2), does not exceed the number || for some constant .
With regard to point (ii.3), if (ii.1) and (ii.2) are satisfied, then looks like
where , ,..., are clauses. According to point (i.5), these clauses are recognized by Turing machines in no more than
c(++... +)
operations for some constant c. On the other hand, it is obvious that
(++... +).
Therefore, it is easy to see, that the total number of operations required to accept or reject the string , does not exceed the number c .
(iii) The general operating principles of the Turing machine are similar to those of the . To recognize the string of the language SUB(), does the following:
(iii.1) checks whether the string starts with the symbols ,
(iii.2) checks whether a binary code follows any occurrence of the symbol .
(iii.2) checks whether the current binary code is followed by the symbol or the special symbol "end of string".
(iii.4) checks whether the number of occurrences of the symbol is less than or equal to .
(iii.5) checks, whether the index of the current literal differs from the indices of other literals included in the string.
If any of these points has a negative answer, rejects the string and accepts it otherwise.
Obviously, to accept or reject the string , needs no more than c operations.
(iv) The general operating principles of the Turing machine .
To recognize the string of the language PAIR(), does the following:
(iv.1) checks whether consists of two substrings separated by the symbol ‘▫’.
(iv.2) checks whether these substrings are included in the language ().
(iv.3) checks whether the intersection of these substrings is empty.
(iv.4) checks whether one of the substrings differs from .
Taking into account the previous reasoning, it can be argued that the total number of operations required to accept or reject a string does not exceed the number c .
(v) Let’s now describe the general workflow of Turing machine that recognizes the string of language d(, ) in a polynomial time.
That is, receiving the string w, the Turing machine runs over it and does:
(v.1) checks if the string w consists of substrings separated from each other by ( – 1) symbols '⋆'.
(v.2) checks whether each substring is included in PAIR().
(v.3) checks whether the number of elements with pairwise different indices in the string is equal to .
If any of those conditions is not satisfied, then the rejects the string.
To estimate the number of operations for point (v.1), It is enough to check:
1) whether the number of occurrences of the symbol '⋆' is equal to ( – 1),
2) whether any occurrence of the symbol '⋆' is located between some binary code and the symbol .
Obviously, the number of required operations does not exceed the number c |w |.
Point (v.2): let || be the number of symbols included in the -th substring. Then, to check if the -th substring is included in PAIR(), needs to perform c operations. Since || + || +... + || |w|, then to check if all substrings are included in (), needs to perform c operations.
Point (v.3): if (v.1) and (v.2) are satisfied, then the string contains elements with binary codes. Receiving the string w, does the following:
1) records on the first work tape, and marks an element in it. Let it be the element .
2) records on the second work tape.
runs over the string and sequentially compares all non-marked elements in it with the element . All elements in that have the same index as are marked.
Running through the entire string w, continues as follows:
1) records on the output tape,
2) looks for the next non-marked element in and, finding it, repeats the described operations.
If there are no unmarked elements left in w, then obviously the output tape contains all elements with pairwise distinct indices. So, compares their number with .
Taking into account the arguments in (i.5), it can be argued that the number of needed operations does not exceed the number .
Thus, strings of any of the described languages are recognized in polynomial time with respect to the length of the input string.
4. Reducibility of Languages
Although there are different definitions of the concept of polynomial reducibility
| [4] | Cook, S. A., The complexity of theorem - proving procedures. In Conference Record of Third Annual ACM Symposium on Theory of Computing (1971), 151–158. |
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
| [18] | Rogers, H., Jr.: Theory of Recursive Functions and Effective Computability. MIT Press, Cambridge (1987). |
[4, 11, 18]
, in general they all express a similar relationship between different languages. In this section we will study the reducibility of the Boolean satisfiability problem to the problem of existence of a special covering for a set and vice versa. We will use definitions from
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
| [11] | Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103. |
[2, 11]
.
Let we are given a Boolean function (,..., ) represented in conjunctive normal form with clauses, and let S = {, ,..., } be any non-empty tuple of elements. Recall that we use the notation for instead of the string () of the alphabet .
To each element of the set S, we associate a clause of the function (,..., ) so that the element = eb() corresponds to the -th clause of the function in the sequential enumeration of the clauses. We will call eb(j) the number or the code of the clause, and will identify it with its corresponding clause. So, for brevity, we will denote the set of clauses of the function (,..., ) as S() = {,..., } and use these elements as clauses. So, the entry will mean the inclusion of the literal in the clause corresponding to . Also, the notation ⟨⟩ ∈ CLAUSE(), will mean that the clause corresponding to belongs to the language CLAUSE() and the string ⟨⟩ is formed by the clause . So, we designate the following string by :
Obviously, will be the string corresponding to the function (,..., ) in conjunctive normal form, and (,..., ) will be a function corresponding to the string . To denote the subsets of clauses will be used the capital letters corresponding to the function designation:
For some i [1, ] we form the following sets:
= { / ∈ S() and } and
= { / ∈ S() and }.
Obviously, ⊆ () and ⊆ S().
Proposition 4.1. If for some natural numbers and ,
∈ CNF(, ), then
1) ∀ i ∈ [1, ] ⟨ ▫ ⟩ PAIR(),
2) = S.
Proof. To proof of (i) it is enough to prove that for any [1, ],
1) ⟨ ⟩ () and ⟨⟩ (),
2) ⋂ ∅,
3) ∅,
The proof follows from definitions of languages (), PAIR() and CNF(, ).
The proof of (ii) follows from the definitions of the sets and .
Lemma 4.2. For any natural numbers and and for any string CNF(, ), there exists a Turing machine that, receiving the string , outputs the string ⟨ ▫ ⋆... ⋆ ▫ ⟩ in polynomial time with respect to the length of the string .
Proof. Let’s describe the general workflow of such a Turing machine, with alphabet .
Similar to Proposition 3.2, we will use a Turing machine denoted by
, with input tape, output tape and with two work tapes
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
[2]
. The
’s operation procedure consists of following stages:
Receiving a string of clauses, records the codes of clauses on the first work tape in the same order in which the clauses are on the input tape.
To form the current strings and for ∈ [1, ], uses the second work tape, successively recording the pairs (, 0) and (, 1) on it. We say that scans a code or a pair of indices, meaning that it scans the symbols that form them.
After recording the numbers of clauses, starts working, recording (1, 0) on the second work tape and 𝜀 on output tape.
Еach action of is determined by configuration of four records on different tapes scanned at current moment. We denote it (, , , ) with the following meanings:
is current scanned record on input tape,
is current scanned record on first work tape,
is current scanned record of pair (, 0) on the second work tape, where ∈ [1, ],
is current scanned record on output tape.
The first configuration is ( , , (, 0), 𝜀), is the first symbol of the string , {0, 1}.
Аt the beginning of the work, scans these records on the tapes.
To form and , performs actions depending on configuration:
with configuration (, , (, 0), 𝜀),
1) records instead of 𝜀, on the output tape,
2) scans the symbol on the output tape,
3) scans the symbol following of on the input tape,
with configuration (, , (, 0), ),
1) adds to the output tape and scans it,
2) scans the symbol following of on the input tape,
with configuration (, , (, 0), 𝜀) or (, , (, 0), ), where ,
scans the symbol following of on the input tape,
with configuration (⋆, , (, 0), ),
1) scans the symbol on the first work tape
2) scans the symbol following of the symbol '⋆' on the input tape,
with configuration (end of input string, , (, 0), ),
1) adds the symbol ‘▫’ after on the output tape,
2) records the pair (, 1) on the next place following the pair (, 0) and scans it,
3) - records the symbol 𝜀 after the symbol ‘▫’ on the output tape and scans it,
4) scans the first symbol on input tape,
with configuration (, , (, 1), 𝜀) or (, , (, 1), ),
scans the symbol following of on the input tape,
with configuration (end of input data, , (, 1), ) and for < ,
1) adds the symbol ‘⋆’ on the next place following the on output tape,
2) records the symbol 𝜀 on the next place of ‘⋆’ on the output tape and scans it,
3) records the pair (+1, 0) on the next place following the pair (, 1) on the second work tape and scans it,
scans the first symbol on input tape,
with (end of input data, , (, 1), ), the Turing's machine stops.
It is easy to see that outputs the string
Also, the number of actions performed by to complete the described procedure is polynomial with respect to the length of input data of the string , denoted by ||. More precisely, the number of mentioned operations does not exceed the number for certain constant .
Let's denote by () the string formed as a result of 's work on input :
()=⟨▫⋆...⋆▫⟩.
Lemma 4.3. For any natural numbers and ,
CNF(,)if and only if()(,).
Proof. Obviously, if CNF(, ) then, according to Proposition 4.1 i),
() =⟨▫⋆...⋆▫⟩d(,).
Now, suppose that () d(, ). In this case for any [1, ] the following holds:
1) ∅, thus, no clause is included in the subsets and simultaneously.
2) ∅, that is ∅ or ∅.
In fact, for any [1, ], we get the following:
1) there is no clause including the literals and simultaneously.
2) the literal is included in some clause or the literal is included in some clause.
It means that the number of literals with pairwise different indexes is equal to .
In addition, each clause included in some set cannot be empty, since if , then . Therefore CNF(, ).
We denote by the special decomposition of the set of clauses of the function :
dS={(,),..., (,)}.
If there is a special covering for S
in the decomposition dS(
), we denote it as
S(
)
:
S()={,,...,}.
For natural numbers and , we define the languages sat(, ) and sC(, ): satCNF(, ) = {⟨⟩ / is in CNF with clauses and is a satisfiable function}, sC(, ) = {⟨ ▫ ⋆... ⋆ ▫ ⟩ d(, )/there is a tuple (,..., ) suchthat
=}.
Theorem 4.4. For any natural numbers and ,
satCNF(,) if and only if()sC(,).
Proof. Suppose that for some natural and , sat(, ) and (,..., ) is the function corresponding to the string . According to the definition, (,..., ) is represented in conjunctive normal form with clauses and is a satisfiable function. That is, there is a Boolean tuple (,..., ) such, that (,..., ) =1.
We show, that the set {, ,..., } is a special covering for the set .
By Proposition 4.1 and Lemma 4.3, it suffices to prove that = . Let's show that any clause of the set is included in some subset
⊆{,,...,}
Let there be a clause that is not included in any of these subsets. This means that none of the literals ,..., is included in the clause , and thus is a disjunction of some literals of the form . Since 0 for any i ∈ [1, ], then for given assignment of variables = 0, which contradicts the assumption that (,..., ) =1. Therefore, any clause is included in some subset that is included in the set {, ,..., }, So this set is a special covering for S(),
=.
Therefore,
() =⟨▫⋆...⋆▫⟩(,).
Now assume that for some natural numbers and , () sC(, ). This means that () (, ) and there are (,...,) such that the set {,..., } is a special covering for the set .
Recall that the literal is included in all clauses of the subset . Therefore, if = 1, then the value of all clauses in , is equal to 1, that is:
for any [1, ] and [1, ], if = 1 and , then = 1.
Therefore, if =,...,=, then (,..., ) = 1.
Comparing this with the results of Lemma 4.3, that is:
() d(, ) if and only if CNF(, ),
we obtain that satCNF(, ).
Remark 4.4.1. According Proposition 3.2, the Turing machine recognizes the strings of language CNF(, ) in a polynomial time with respect to the length of string.
Let's for any natural numbers and , define the function : → as follows:
() = (w), if w CNF(, ) and () = , if w CNF(, ).
It is evident, that
is a polynomial time computable function
| [2] | Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007. |
[2]
with computable time not exceeded the number
for certain constant
.
Also, it is evident, that for any string and for natural numbers and ,
CNF if and only if () d(, ).
Recall, that and d(, ).
Theorem 4.5. For any natural numbers and ,
Proof. It is obvious that satCNF(, ) ⊆ CNF(, ) and sC(, ) ⊆ d(, ).
By Lemma 4.2, the Turing machine generates the string () in polynomial time for any string (, ). According to Theorem 4.4 and Remark 4.4.1, for any string , and for any natural numbers and ,
satCNF(, ) if and only if () sC(, ).
Since is a polynomial time computable function, then the language satCNF(, ) is reduced polynomially to the language sC(, ).
Now let’s show that the problem of the existence of a special covering is polynomially reducible to the sat problem. Let {,..., } be a nonempty set of elements composed of the alphabet as above. Let also ⟨⟩ be a string of the language (, ):
⟨dS⟩=⟨▫⋆...⋆▫⟩d(,).
We form the string belonging to the language CNF(, ), based on the string ⟨dS ⟩.
Let for any element , () be the set of literals composed as follows:
() = {/ (∈[1,]) & () & ({})}.
In addition, let l() be the clause formed by literals of the set L() and let () be the string over the alphabet , which forms by the set L():
() = ⟨ ... ⟩, where any literal belongs to the set L().
We compose the string ⟨ () ⋆ () ⋆... ⋆ () ⟩ over the alphabet , which corresponds to the Boolean function in conjunctive normal form with clauses, denoted by (dS) = .
It is easy to see, that as a result of formation of all clauses (), the number of literals
in clauses with pairwise different indexes will be equal to . Therefore,
⟨()⋆()⋆...⋆()⟩CNF(,).
Lemma 4.6. If ⟨dS ⟩ = ⟨ ▫ ⋆... ⋆ ▫ ⟩ d(, ), then the string
is formed in polynomial time with respect to the length of the string ⟨dS ⟩.
Proof. Similar to the proof of Lemma 4.2, we describe the general workflow of a particular Turing machine, denoted by , over the alphabet , which time outputs the string
when input the string
Let’s consider a Turing machine , with input tape, output tape and two work tapes.
The general principles of ’s operation are as follows:
To form the clause (), it runs over the symbols of input data and with finding the element included in , adds the literal to the literals forming the clause () on the output tape.
At the first stage of work, records pairs of indexes (j, ) of all subsets on the first work tape in the same order in which the subsets are on the input tape.
The second stage of work consists of forming the clauses () for i [1, ].
In order to generate a clause corresponding to the element , uses the second work tape, adding on it and scanning during the formation procedure ().
After recording the pairs (j, ), starts work by recording on the second work tape.
To determine each step of it is enough to consider the configuration of three current scanned records on different tapes, which we denote by (, , ,):
is the scanned symbol on input tape,
is the scanned pair of indexes on the first work tape of considering subset,
is the scanned element on the second work tape, that is, the element if the clause () is forming.
The first configuration that will be considered to start working over the input data, is
where is the first symbol of input data.
To form (), the Turing's machine performs actions depending on configuration:
with configurations (ε, (, ), ) or (, (, ), ), where ,
scans the next symbol on input tape.
with configuration ( , (, ), ),
1) adds the literal on output tape,
2) scans the next symbol on input tape.
with configuration (▫, (, 0), ),
1) scans the next symbol on input tape,
2) scans the pair (, 1) on the first work tape.
with configuration (⋆, (, 1), )
1) scans the next symbol on input tape,
2) scans the pair (+1, 0) on the first work tape.
with configuration (end of input string, (, 1), ) and < ,
1) adds ⋆ to the output tape,
2) adds the symbol to the second work tape and scans it,
3) scans the first symbol of input tape,
4) scans the pair (, 0) on the first tape,
5) starts to run over the input data again, to detect the element .
with configuration (end of input string, (, ), ), stops.
Obviously, on the output tape we will obtain the string
It is easy to see that the number of actions performed by to complete the described procedure is polynomial with respect to the length |dS| of the string ⟨dS ⟩.
The number of mentioned actions does not exceed the number .
Let's denote by (dS) the string formed as a result of 's work on input ⟨dS ⟩:
(dS) =⟨()⋆()⋆...⋆()⟩.
Obviously, forms the string () based on the string ⟨dS ⟩ for any special decomposition of the set {,..., }.
Theorem 4.7. For any natural numbers and ,
⟨dS ⟩ sC(, ) if and only if (dS) satCNF(, ).
Proof. Let ⟨dS ⟩ sC(, ). This means that the total number of elements with pairwise different indexes in all subsets is equal to . So, each of the elements ,..., is included in some of subsets forming the string ⟨dS ⟩, and there is a Boolean tuple (, ,..., ) such that
=.
This means that for any element , there exists a subset
∈ {, ,..., } such that
On the other hand, if then l(). Thus, the number of forming clauses will be , which means that the number of strings corresponding to clauses also will be .
Let's for simplicity denote by = (), that is = ⟨ () ⋆ () ⋆... ⋆ () ⟩.
Also, we denote by the function corresponding to the string .
Since = implies = 1, then ( = ) &... & ( = ) implies
(,..,) =()(,..,) =1.
Therefore, () = ⟨ () ⋆ () ⋆... ⋆ () ⟩ satCNF(, ).
Now suppose, that () sat (, ). That is, is a satisfiable function, which means that for some Boolean tuple (,..., ), (,,..., ) =1.
According to Theorem 4.4,
sat (, ) if and only () (, ).
Since () = ⟨ ▫ ⋆... ⋆ ▫ ⟩, then for some Boolean tuple ,..., , we obtain
=.
This means that for any clause (), there exists a subset such that
∈{,,...,} and()∈.
But then , because of definition of :
= {() / () ∈ () and () contains , ( ∈ [1, ])}.
At the same time the clause () contains the literal only if .
Since any element determines the composition of one clause, and any clause is defined by one element, then it is easy to prove that for any element there exists a subset
{, ,..., } such, that .
So, = .
Therefore, ⟨ ▫ ⋆... ⋆ ▫ ⟩ sC(, ).
Remark 4.7.1. According Proposition 3.2, the Turing machine recognizes the strings of language d(, ) in a polynomial time with respect to the length of string. Мore precisely, this time is estimated as , where is an input string.
Let's for natural numbers and , define the function : → as follows:
() = (w), if w d and () = ⟨ ▫ ⟩ if
It is evident, that is a polynomial time computable function with computable time not exceeded the number for certain constant .
It is also obvious that for any natural numbers and , and for any string ,
if and only if () CNF.
Recall, that and (, ).
Theorem 4.8. For any natural numbers and , sC(, ) satCNF(, ).
Proof. It is obvious that sC(, ) ⊆ d(, ) and satCNF(, ) ⊆ CNF(, ).
According to Lemma 4.6, for any natural numbers and , there is a Turing's machine , which for any string
⟨dS⟩=⟨▫⋆...⋆▫⟩d(,)
forms the string
() =⟨()⋆()⋆...⋆()⟩
in polynomial time with respect to the length of string ⟨⟩. According to the Theorem 4.7 and Remark 4.7.1, for any string , and for any natural numbers and ,
⟨dS ⟩ sC(, ) if and only if (dS ) satCNF(, ).
Therefore, sC(, ) satCNF(, ).
Since is a polynomial time computable function, then the language sC(, ) is polynomially reduced to the language satCNF (, ).
Theorem 4.9. For any natural numbers and , the language satCNF (, ) and the language sC(, ) are polynomially equivalent.
Proof. Follows of Theorems 4.5 and 4.8.
Corollary 4.9.1 The problem of existence of a special covering is an -complete problem.
Proof. Follows from the Theorem 4.9.
The theorem 4.9 gives us possibility to use the concept of special decomposition when discuss the questions concerning to satisfiability of a function. That is, instead of investigating questions related to the satisfiability a given function in conjunctive normal form, we can investigate corresponding questions related to the existent of a special covering for the set of clauses under a special decomposition of this set.
5. Replaceability of Subsets
In this section, to study important properties of special decompositions, we introduce a new concept called replaceable subsets.
Let = {,..., } be a nonempty set, and let for some Boolean tuple (,..., ),
, ,..., , be arbitrary subsets of the set such that the set
=,,..., (,)}
is a special decomposition of the set .
Recall that in this case
= {,..., } and = {,..., }.
Definition 5.1. If for some ∈ {0,1}, the set of -components of the special decomposition covers the set , then it will be called a special -covering for the set .
According to Lemm 1.5 in
, there exists a special covering for the set
under the decomposition
if and only if for some
∈ {0,1} there exists an
-covering for the set
under some special decomposition
. The search for an
-covering in a decomposition
consists of finding ordered pairs such that, by permuting their components, the missing elements of the
-domain are moved to the
-domain.
Obviously, if the 0-domain of some special decomposition covers the set , then permutating the components of all ordered pairs of this decomposition, we obtain -covering under another special decomposition and vice versa. So, the notation -covering, will mean that ∈ {0, 1}.
Definition 5.2. Let be a special decomposition of a set such that and the -domain of the decomposition does not cover the set .
1) We say that the subset is an immediate -replaceable subset, if ().
2) We say that is an -replaceable subset if it is an immediate -replaceable or, if contains ordered pairs (let ,..., be their indices) such that (, ,..., ) .
3) We say that is an -reachable element if there is an ordered pair (, ) such that
() & ( ∉ ) ( ∈ ), and is an -replaceable subset. We will also say that the element is associated with -replaceability of the subset .
The essence of the concept of
-replaceability is to perform permutations of the components of some ordered pairs, as a result of which the
-domain receives a new element without losing its own elements. It is easy to see the
-replacement of a subset is an
-transformation of the given decomposition. Therefore, according to the Lemma 1.5 in
, for any special decomposition, as a result of any replacement, we obtain a new special decomposition.
Theorem 5.3. Let for some Boolean tuples (,..., ) and (,..., ), the set
S= {,...,,...,
be a special covering for the set S under the special decomposition ,
S=,,..., (,)}.
Then, for any [1, ], the subset is an -replaceable subset.
Proof. For any [1, ], if () , then is an immediate -replaceable subset. Suppose that for some [1, ], the subset contains elements that are not included in other subsets of the -domain. Since is a special covering for the set , then obviously, for any element there is a subset such that () & .
Suppose that for some ,..., {0, 1}, ,..., are the subsets such that
({,...,}) & (.
It is obvious that some of these subsets are included in the -domain, since by assumption, is not immediate replaceable subset. Let them be the subsets ,..., . That is,
({,...,})& ({,...,}).
Let’s consider the case, when = . For = , will be a similar proof. In this case, the ordered pair , is the same as , . But then {,..., } .
Therefore, the subsets ,..., are moved to the -domain by permutations of the components of the ordered pairs
,,,...,.
If some of the subsets ,..., contain elements that are not included in other subsets in the -domain, then by the same reasoning as for the subset , we find the corresponding ordered pairs and perform permutations of their components.
Since as a result of all permutations new subsets included in move into the -domain, this domain will not lose elements. Therefore, is an -replaceable subset.
Corollary 5.3.1. Let a special decomposition of the set be given such that some element is not included in the -domain of this decomposition, ∉ .
If is not an s-reachable element, then there is no special covering of the set under the decomposition of .
Proof. Follows directly from Theorem 5.3.
Corollary 5.3.2. If there exists a special covering for the set under the decomposition , then for any [1, ] the following is true:
the subset is s-replaceable or the subset is -replaceable.
Proof. Let for some Boolean tuple (, ,..., ), the set S = {,..., be a special covering for the set . Obviously, the conditions of Theorem 4.2 are satisfied. So,
for = 0, then the subset is an -replaceable subset,
for = 1, then the subset is an s-replaceable subset. ∇
In search of -reachability of an element S such that ( ∉ ) ( ∈ ), we look for ordered pairs that ensure this reachability. At the same time, an important question arises when studying the existence of a special covering for a set.
Let {,..., } \ . The elements ,..., can occur in different subsets in the -domain of the decomposition S. So, to find a special covering for the set , we can perform a sequential search for -reachability of each element of the set {,..., }:
1) search for ordered pairs that will ensure the s-reachability of an element included in the set {,..., } under the decomposition S, and, having found them, permute their components. The result will be a new special decomposition.
2) we perform the same procedure for some other element of the set {,..., } under the new decomposition and continue the similar procedure for all elements.
Let’s find out whether finding a special covering depends on the order in which the missing elements are considered.
Definition 5.4. Let we are given a special decomposition S of the set S. For an ordered set {,..., } S, we define a decomposition denoted by (,..., ):
(i) if , then coincides with the decomposition S.
(ii) if , then we consider the following two cases:
(ii.1) is an s-reachable element under the decomposition S.
In this case, () is defined as a decomposition obtained by permuting the components of the ordered pairs that ensure this reachability.
(ii.2) is not an s-reachable element under the decomposition S.
In this case, we consider the resulting decomposition as an empty set, = ∅.
(iii) let for some 1 k < l, (,..., ) .
If the element is included in the -domain of this decomposition, then the decomposition (,..., ) coincides with the decomposition ,..., .
If is not included in the -domain of the decomposition (,..., ), then we consider the following two cases:
(iii.1) is an s-reachable element under the decomposition (,..., ).
In this case, (,..., ) is defined as a decomposition that is obtained by permuting the components of ordered pairs that ensure this reachability.
(iii.2) is not an s-reachable element under the decomposition (,..., ). In this case, we will consider the decomposition (,..., , ) as an empty set.
(iv) if for some 1 k l, (,..., ) = ∅, then also, (,..., , ) = ∅.
Theorem 5.5. Let the special decomposition of the set be given such that
(i) if there exists a special covering for the set under the special decomposition , and {,..., } is an arbitrary permutation of the elements of the set {,...,}, then:
(b) the -domain of the decomposition ,..., is an s-covering for S.
(ii) if ,..., = ∅ for an arbitrary ordered set {,..., } consisting of some elements of the set {,...,}, then there does not exist a special covering for the set S under the decomposition S.
Proof. (i) Let for some Boolean tuple (,..., ), the set S = {,..., } be a special covering for the set under the decomposition S. The condition S \ = {,...,} implies that S s and {,...,} . Therefore, for any {,...,}, there is a subset included in S, which contains the element .
Let ,..., , be subsets such that the elements of the set {,...,} are located these subsets, where {,..., } {,..., }. In addition,
({,...,}) & (,...,S).
Let for some {,..., } {,..., }, all elements of the set {,...,} be located in the subsets ,..., , in addition,
({,...,}) & (,...,S).
It is easy to see that for any subset {,..., } the conditions of Theorem 5.3 are satisfied, which means that the subset is -replaceable. Without limiting the generality of the reasoning, we can assume that . So, as a result of -replacement of the subset , we obtain the special decomposition ∅.
Since the transition from the decomposition
to the decomposition
is an
-transformation, then according to Lemma 1.5 in
, there exists a special covering for
under the decomposition
(
). If the element
has moved to the
-domain as a result of an
-replacement associated with the element
, then according to Definition 5.4,
) = and .
If has not moved to the 0-domain, then by the same reasoning as in the case of the element , there exists a subset such, that (S) & (.
By Theorem 5.3, the subset is -replaceable. Since the replacement is associated with the element , then performing the -replacement of the subset , we obtain:
1) ∅,
2) is a special decomposition,
3) there is a special covering for the set under the decomposition .
Repeating the similar procedure, no more than times, we obtain:
1) ,..., ∅,
2) ,..., is a special decomposition,
3) there is a special covering for the set under the decomposition ,..., .
It is obvious that when forming the decomposition ,..., all elements of the set {,..., } move into its 0-domain. At the same time, the 0-domain of the corresponding decomposition does not lose elements at any stage. Therefore, the -domain of the decomposition ,..., is an -covering for the set .
(ii) Now let {,..., }, where , be an ordered set obtained by an arbitrary permutation of arbitrary elements of the set {,...,}, such that that (,..., = ∅.
Recall, that (,..., = ∅ in the following cases:
(ii.1) () = ∅. This means, that under the decomposition there does not exist -replaceable subset, associated with so, there does not exist a special covering for S.
(ii.2) for some element 1 ≤ <,
(,..., ∅ ,...,, = ∅.
This means that under the decomposition
(
,...,
, there does not exist an
-replaceable subset associated with the element
. But then, by Corollary 4.2.1, there cannot exist a special covering for the set
under the decomposition
(
,...,
. Since the decomposition
(
,...,
is obtained as a result of an
-transformation of the decomposition
, then by Lemma 1.5 in
, the decomposition
does not allow a special covering for the set S. ∇
6. Applications
Let S = {,..., } be the set of clauses the Boolean function (,..., ), and let
S()) ={(,),..., (,)}
be special decomposition of the set S.
For a subset () S and () ∅, we say that () is a satisfiable subset if there exists a Boolean assignment tuple (,..., ), such that every clause included in () evaluates to 1 when assigning values ,..., to variables ,..., .
Theorem 6.1. Let (,..., ) be a function represented in conjunctive normal form with clauses, and let ) be a special decomposition of the set S).
Then, as a result of any -transformation of the decomposition S(), the set of clauses S) is divided into two satisfiable subsets.
Proof. Let for some Boolean tuple (,..., ), the set
,...,)I (S()) = {(,),..., (,)}
be an -transformation of the decomposition S(). Then, ,..., will be as follows:
= 0, if {,..., } and = 1, if {,..., }.
Consider an arbitrary subset in the -domain of this decomposition ∈ {,..., }
and the clauses included in it. By definition
= { / ∈ S() and contains the literal , ∈ [1, ]}.
Obviously, if = then all clauses in the subset will take the value 1. So, if = ,..., = , then the set of clauses included in the 0-domain of this decomposition will be satisfiable.
It is easy to see that by the same reasoning as for the 0-domain, (,..., ) will be the satisfying tuple for the 1-domain. Obviously, if () and () denote the sets of clauses included in the 0-domain and 1-domain, respectively, then S = () (). ∇
Remark 6.2. Recall that any Boolean function in conjunctive normal form generates a special decomposition of the set of its clauses, and any special decomposition of a set generates a Boolean function represented in conjunctive normal form. In sec. 6 in
is shown that by permuting the components of an ordered pair, new function is generated.
Let S() be a special decomposition generated by the function (,..., ). Consider an ordered pair (, ) ∈ S(), assuming that
= {,..., }and = {,..., }.
By the definition of these subsets,
1) the literal is included in all clauses of the set {,..., },
2) the literal is included in all clauses of the set {,..., }.
3) the literals and are not included in any other clauses.
When permuting the components of the ordered pair (, ), we obtain the special decomposition ()(()), in which the -th ordered pair has the form (, ). The remaining ordered pairs coincide with the corresponding ordered pairs of ().
()(S()) ={(,),..., (,),..., (,)}.
We form a function denoted as (),..., ) in accordance with Section 3 based on the special decomposition ()(S()). Recall that if
S = {(,),..., (,)}
is a special decomposition of a set S = {,..., }, then for any element ∈ {,..., }, the clause () will formed by the following set of literals, { / }. Respectively,
(),...,) =.
The ordered sets ()) and ()(S()) differ only in the -th ordered pair. That is,
= {,..., } is located in the 1-domain,
= {,..., } is located in the -domain, of the resulting decomposition.
Let’s denote by ,..., the clauses of the function (,..., ). That is,
Since (,..., ) is generated by the decomposition ()(()), then:
1) for any ∈ {,..., }, the corresponding new clause will contain the literal
2) for any ∈ {,..., }, the corresponding new clause will contain the literal .
Let S() = {(, ),..., (, )} denotes the special decomposition ()(S()). According to the formation procedure of the function (,..., ), we obtain:
1) the literal is included in any of the clauses included in ,
2) the literal is included in any of the clauses included in .
At the same time, the clauses of the function ()(,..., ), not included in the subsets or , coincide with the corresponding clauses of the function (,..., ). Thus, the function (,..., ) is obtained by replacing the literal with the literal and the literal with the literal in all clauses of the function (,..., ) containing these literals.
We will say that the function (),..., ) is obtained by inverting the literals of the variable in the function (,..., ).
Similarly, the expression (,..., )(,..., ) will mean the function generated by the decomposition (,..., )(S()), for any ,..., [1, ].
Theorem 6.3. A function (,..., ) represented in conjunctive normal form is satisfiable if and only if the function (,..., )(,..., ) is satisfiable.
Proof. Let ()) = {(, ),..., (, )} be a special decomposition of the set . Consider the special decomposition (,..., )(()). By definition,
(,..., )(S)) = {(, ),..., (, )},
( = 0, if ∉ {,..., } and = 1, if {,..., }).
Suppose that the (,..., ) is a satisfiable function, that is, there exists a Boolean tuple (,..., ) such that (,..., ) = 1. Using the arguments of Remark 6.2 regarding the inversion of literals, it is easy to see that the function {,..., }(,..., ) will be satisfiable by the assignment tuple (,...,) if we define this tuple as follows:
= , if ∉ {,..., } and = , if {,..., }.
That is, {,..., }(,...,) = 1.
Obviously, the opposite is also true.
If {,..., }(,...,) = 1 for some Boolean assignment tuple (,...,) then there is a tuple (,..., ) such that f(,..., ) = 1. ∇
Definition 6.4. A conjunctive normal form of a Boolean function will be called a Proportional Conjunctive Normal Form, if each clause contains at least one negative literal or if each clause contains at least one positive literal.
Theorem 6.5. A Boolean function (,..., ) represented in conjunctive normal form is satisfiable if and only if it can be transformed into a function in Proportional conjunctive normal form using literal inversions.
Proof. Let the ordered set S()) = {(, ),..., (, )} be a special decomposition of the set of clauses S of the function (,..., ).
One part of the theorem is obvious. Suppose that the function is transformed into a function represented in Proportional conjunctive normal form using literal inversions. Let it be the function ,..., ). It is easy to notice, that a function in proportional conjunctive normal form is satisfiable, so by the Theorem 6.3, the function (,..., ) is satisfiable.
The opposite: Let (,..., ) be a satisfiable function. Then, there is a Boolean tuple (,..., ) such that (,.., ) = 1. Hence, according to Theorem 4.9, there is a special covering for the set S under the decomposition S. Let it be the set S = {,..., }.
1) If the set is an -covering for the set , then all clauses are found in the -domain of the corresponding decomposition, so by the arguments of Remark 6.2, all they contain a negative literal, if =0, or all they contain a positive literal, if =1.
2) Assume that ,..., are clauses of the function such that for some ,
Since there is a special covering for the set S then by Theorem 4.4, {,..., } is a reachable set. Suppose that {(, ),..., (,)} is the set of replacement steps of the decomposition S that ensure the -reachability of all elements {,..., }. After the permutation the components of all these ordered pairs we obtain the special decomposition (,..., )(S)). Obviously, as a result, all clauses of the set S will be in the -domain of the resulting decomposition.
Consider the function (,..., ),..., ) generated by the special decomposition.
Since all clauses of this function are included in the -domain of the decomposition.
then all they contain a negative literal, if = 0, or all they contain a positive literal, if = 1.
This means that, the function (,..., ),..., ) is represented in proportional conjunctive normal form. At the other hand, the function (,..., ),..., ) is obtained by inverting the literals of the variable ,..., in the function (,..., ).
Thus, if (,..., ) is a satisfiable function, then it can be transformed into a function represented in proportional conjunctive normal form using literal inversions. ∇
7. Instead of an Afterword
The importance of the result of Theorem 5.5 is that for any {0, 1}, having a set of elements {,...,} not included in the -domain of the given decomposition, we can search for the -reachability of each of these elements, considering them in any order.
The importance of the result of Theorem 6.5 is that the theorem describes one of the necessary natures of the class of satisfiable Boolean functions. That is:
The function is included in this set if and only if it can be transformed into a function in Proportional conjunctive normal form using literal inversions.
At the same time, some important questions associated with these results remain open: How to find ordered pairs that ensure the reachability of a given element, or how conclude that such ordered pairs do not exist. Also, how find the required literals for further inversion.
These questions will certainly determine the direction of research in the next article.
Abbreviations
CNF | Conjunctive Normal Form |
satCNF | Satisfiability of Conjunctive Normal Form |
Author Contributions
Stepan Margaryan is the sole author. The author read and approved the final manuscript.
Conflicts of Interest
The author declares no conflicts of interest.
References
| [1] |
Allender, E., Bauland, M., Immerman, N., Schnoor, H., Vollmer, H. The complexity of satisfiability problems: Refining Schaefer’s theorem. J. Comput. Syst. Sci. 75(4), 245–254 (2009).
|
| [2] |
Sanjeev Arora, Boaz Barak, Computational Complexity: A Modern Approach 2007.
|
| [3] |
Armin Biere, Marijn Heule, Hans van Maaren and Toby Walsh, Handbook of Satisfiability, IOS Press, 2008.
|
| [4] |
Cook, S. A., The complexity of theorem - proving procedures. In Conference Record of Third Annual ACM Symposium on Theory of Computing (1971), 151–158.
|
| [5] |
Yves Crama, Peter L. Hammer, Boolean Functions. Theory, Algorithms, and Applications, 2011.
|
| [6] |
Peter G´acs, Boston University and L´aszl´o Lov´asz, Yale University, Complexity of Algorithms Lecture Notes, Spring 1999.
|
| [7] |
Michael R. Garey, David S. Johnson, and Larry J. Stockmeyer. Some simplified NP-complete graph problems. Theoretical Computer Science 1(3): 237–267, 1976.
https://doi.org/10.1016/0304-3975(76)90059-1
|
| [8] |
S. A. Gizunov and V. A. Nosov, Recognition complexity for Sheffer classes, Mosc. Univ. Math. Bull. 51, no. 4, pp. 86–88, 1996. UDC 519.716.
|
| [9] |
A. Horn, On sentences which are true of direct unions of algebras. Journal of Symbolic Logic. 16(1): 14–21, 1951.
https://doi.org/10.2307/2268661
JSTOR 2268661. S2CID 42534337.
|
| [10] |
Thomas Jech, Set Theory, The Third Millennium Edition, 2003.
|
| [11] |
Karp, R. M., Reducibility among combinatorial problems. In Complexity of Computer Computations (1972), R. E. Miller and J. W. Thatcher, Eds., Plenum Press, 85–103.
|
| [12] |
(L. A. Levin, “Universal problems of full search”, Probl. Inf. Transm., 9: 3 (1973), 265–266).
|
| [13] |
Stepan Margaryan, Special Coverings of Sets and Boolean Functions, American Journal of Mathematical and Computer Modeling (Volume 10, Issue 3), 84-97.
https://doi.org/10.11648/j.ajmcm.20251003.11
|
| [14] |
J. Donald Monk, Mathematical Logic. Springer-Verlag, 1976.
|
| [15] |
Daniel Pierre Bovet and Pierluigi Crescenzi. Introduction to the Theory of Complexity. Prentice-Hall, New York, 1993.
|
| [16] |
Charles C. Pinter, A Book of Set Theory, 2014.
|
| [17] |
E. A. Potseluevskaya, Approximation of Boolean functions to Schaefer’s classes. Journal of Mathematical Sciences, June 2012, vol 183.
|
| [18] |
Rogers, H., Jr.: Theory of Recursive Functions and Effective Computability. MIT Press, Cambridge (1987).
|
| [19] |
Kenneth H. Rosen, Discrete Mathematics and its Applications, seventh edition, 2012.
|
| [20] |
Thomas J. Schaefer, The complexity of Satisfiability Problems, 1978. Department of Mathematics University of California, Berkeley, California 94720.
|
| [21] |
Edward R. Scheinerman, Mathematics: A Discrete Introduction, Third Edition 2013.
|
| [22] |
Sipser Michael, Introduction to the Theory of Computation, 2012, Cengage Learning.
|
Cite This Article
-
-
@article{10.11648/j.ajmcm.20261101.14,
author = {Stepan Margaryan},
title = {On Important Applications of Special Set Decomposition},
journal = {American Journal of Mathematical and Computer Modelling},
volume = {11},
number = {1},
pages = {39-54},
doi = {10.11648/j.ajmcm.20261101.14},
url = {https://doi.org/10.11648/j.ajmcm.20261101.14},
eprint = {https://article.sciencepublishinggroup.com/pdf/10.11648.j.ajmcm.20261101.14},
abstract = {This paper is devoted to the study of complexity of finding a special covering for a set, as well as to obtaining some important applications of special decomposition. We formulate the problem of existence of a special covering as a decision problem. To determine the complexity class in which this problem is located, we study the relationship between this problem and the Boolean satisfiability problem, treating them as formal languages. We prove that these problems are polynomially equivalent, which means that the problem of existence of a special covering for a set is an -complete problem. In this article we also introduce a new concept ‘Replaceable Subsets’. The properties of such subsets are used to fill in the missing elements needed to obtain a special set covering. It is proved that when searching for missing elements to fill a special covering, the order in which these elements are considered does not matter. This result is of great importance in the search for satisfiability of Boolean functions.},
year = {2026}
}
Copy
|
Download
-
TY - JOUR
T1 - On Important Applications of Special Set Decomposition
AU - Stepan Margaryan
Y1 - 2026/02/06
PY - 2026
N1 - https://doi.org/10.11648/j.ajmcm.20261101.14
DO - 10.11648/j.ajmcm.20261101.14
T2 - American Journal of Mathematical and Computer Modelling
JF - American Journal of Mathematical and Computer Modelling
JO - American Journal of Mathematical and Computer Modelling
SP - 39
EP - 54
PB - Science Publishing Group
SN - 2578-8280
UR - https://doi.org/10.11648/j.ajmcm.20261101.14
AB - This paper is devoted to the study of complexity of finding a special covering for a set, as well as to obtaining some important applications of special decomposition. We formulate the problem of existence of a special covering as a decision problem. To determine the complexity class in which this problem is located, we study the relationship between this problem and the Boolean satisfiability problem, treating them as formal languages. We prove that these problems are polynomially equivalent, which means that the problem of existence of a special covering for a set is an -complete problem. In this article we also introduce a new concept ‘Replaceable Subsets’. The properties of such subsets are used to fill in the missing elements needed to obtain a special set covering. It is proved that when searching for missing elements to fill a special covering, the order in which these elements are considered does not matter. This result is of great importance in the search for satisfiability of Boolean functions.
VL - 11
IS - 1
ER -
Copy
|
Download