Research Article | | Peer-Reviewed

On Important Applications of Special Set Decomposition

Received: 13 January 2026     Accepted: 26 January 2026     Published: 6 February 2026
Views:       Downloads:
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.

Published in American Journal of Mathematical and Computer Modelling (Volume 11, Issue 1)
DOI 10.11648/j.ajmcm.20261101.14
Page(s) 39-54
Creative Commons

This is an Open Access article, distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution and reproduction in any medium or format, provided the original work is properly cited.

Copyright

Copyright © The Author(s), 2026. Published by Science Publishing Group

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 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 .
A well-known theoretical study is Schaefer’s result , 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 . Also, if PNP, 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 . 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 . In addition, the issues of approximation of a function to Schaefer’s classes by fixing some variables of the function are investigated in . 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 , we prove that these problems are polynomially reducible 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 , 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 .
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 = {e1, e2,..., em} be given. Let also for some natural number n,
(M10,M11), (M20,M21),..., (Mn0,Mn1)
be n arbitrary ordered pairs of arbitrary subsets of the set S.
We use the notation dnS for an arbitrarily ordered set of these ordered pairs:
dnS= {(M10,M11), (M20,M21),..., (Mn0,Mn1)}.
The Boolean values αi and α̅i, for i ∈ [1, n ], are used to denote superscripts of subsets:
α̅i= 0 ifαi= 1, andα̅i= 1 ifαi= 0.
The tuple of superscripts (α1,..., αn) of subsets is also called a Boolean tuple.
Definition 2.1. The set dnS will be called a special decomposition of the set S, if
1) ∀i  [1, n] (Mi0  Mi1)= ∅,
2) ∀i  [1, n] (Mi0  Mi1  ∅),
3) i=1n(Mi0Mi1) = S.
Definition 2.2. Let the set dnS be a special decomposition of the set S.
For any Boolean tuple (α1, α2,..., αn) the ordered set
cnS ={M1α1,M2α2,...,Mnαn}
will be called a special covering for the set S under the special decomposition dnS, if
i=1n Miαi= S.
Note that for any i [1, n] the subsets  Mi0 and Mi1 cannot simultaneously belong to the special covering, but one of them exactly belongs.
Let for some natural number n,
dnS = {(M10,M11),..., (Mn0,Mn1)}
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 dnS, let them be
{(Mi10,Mi11),...,(Miк0, Miк1)}⊆dnS,
if the order of pairs in dnS does not change, will be called an I-transformation of the set dnS. The resulting set is denoted as (i1,..., ik )I(dnS) or simply as I(dnS):
I(dnS) ={(M1α1,M1α̅1),..., (Mnαn,Mnα̅n)}.
The ordered pairs included in this decomposition are defined as follows:
(Miαi, Miα̅i) = (Mi0, Mi1), if the components of the i-th pair are not displaced,
(Miαi, Miα̅i) = (Mi1, Mi0), if the components of the i-th pair are displaced.
Obviously, the transition from the set I(dnS) to the set dnS is also an I-transformation.
Recall that, according to Lemma 1.3 in , for any special decomposition of the set S, any I-transformation preserve the possibility of being a special decomposition of the set S and having a special covering for S under such a decomposition.
Thus, with the same pairs of subsets and for any Boolean tuple (α1, α2,..., αn) in generally the special decomposition looks like
dnS={(M1α1,M1α̅1),..., (Mnαn,Mnα̅n)}.
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 M1α1,..., Mnα are called the subsets of 0-domain,
The subsets M1α̅1,..., Mnα̅n are called the subsets of 1-domain.
If the ordered pair (Mnαi, Mnα̅i)  dnS, then the subset Mnαi belongs to the 0-domain and the subset Mnα̅i belongs to the 1-domain. If the components of this ordered pair are permuted, then the subset Mnα̅i becomes a subset of the 0-domain, and the subset Mnαi becomes a subset of the 1-domain.
In addition, for any α  {0, 1}, we will use the following notations:
Mα=i=1nMiαiandMα̅=i=1nMiα̅i.
sMα= {M1α1,...,Mnαn} andsMα̅= {M1α̅1,...,Mnα̅n}.
The set sMα will be called a set of α-components or α-domain of the decomposition dnS.
(i1,..., ik)sMα is the set obtained by replacing the subsets M1α1,..., Mnαn with the subsets M1α̅1,..., Mnα̅n, respectively, in the set sMα.
(i1,..., ik)sMα will be called a set of α-components of the ordered pairs of decomposition (i1,..., ik)I(dnS).
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 f(x1,..., xn) be a Boolean function represented in conjunctive normal form (CNF) with m clauses. It is assumed that the clauses of the function are numbered 1,..., m, so we will use the notation cj for the j-th clause of the function, j ∈ [1, m]. That is,
f(x1,...,xn) =j=1mcj.
The clause cj of the literals xi1α1,..., xikαk is considered with the following conditions:
cj=xi1α1...  xikαk, where i1,..., ik, k∈[1, n], αk∈{0,1}.
In addition, for any i ∈ [1, n], xi0 = x̅i and xi1 = xi.
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 f(x1,..., xn) represented in conjunctive normal form is satisfiable, that is, whether there exists a Boolean tuple (σ1,...,σn) such that f(σ1,...,σn) =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 . To do this, we first form concrete formal languages over some alphabets. In general, we will use the following alphabet:
Σ= {0, 1,x0,x1,⋆, ▫,e,𝜀}.
However, in some individual cases, for convenience, we use the alphabets
Σ1= {0, 1,x0,x1,⋆}⊆ΣandΣ2= {0, 1,⋆, ▫,e,𝜀}⊆Σ.
The expressions will be represented as strings over these alphabets.
The length of a string is considered to be the number of symbols included in it .
The symbols 0, 1, x0, x1 will be used to form different literals. The literals will be used with the following meaning:
xi0=x0b(i) =x̅iandxi1=x1b(i) =xi.
We will use also the notation xiα meaning that α{0,1}.
For simplicity we assume that b(i) is a binary expression of the number i. 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 e, 0, 1 will be used to form expressions such as ei = eb(i), for designation elements of sets, where b(i) is the binary expression of the number i.
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 n and m define the languages CLAUSE(n) and CNF(n, m) over the alphabet
Σ1= {0, 1,x0,x1,⋆}⊆Σ.
For any Boolean tuple (α1,..., αk):
CLAUSE (n) = {⟨ xi1α1. . . xikαk ⟩ / {xi1α1,..., xikαk} is a set of literals such that (k, ij ∈ [1, n]) & (ir  il, if r l)}.
It is important to note, that the language CLAUSE(n) 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
xi1α1 xi2α2. . . xikαk⟩ corresponds to the set {xi1α1, xi2α2,..., xikαk}
as well as we will say that the string is formed by the clause.
Let cji for different indices denote different strings included in the language CLAUSE(n). Then, we define the language CNF(n, m) as follows:
CNF(n, m) = {⟨ cj1cj2 ⋆... ⋆ cjm⟩ / ∀ i ∈ [1, m], cji  CLAUSE(n)}.
Let's now consider the alphabet Σ2 = {0, 1, ⋆, ▫, e, 𝜀}. Using the symbols e, 0 and 1, we compose expressions over the Σ2 to denote elements of an arbitrary set
S={ej1,ej2, ...,ejm}.
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 m we define the languages SAB(m), SABε(m) and PAIR(m) over the alphabet Σ2 as follows:
SUB(m) = {⟨ej1 ej2 ... ejk⟩/ (k ∈ [1, m]) & (jp  jq, if p  q)}.
SUBε(m) = {𝜀} SUB(m).
Note that the language SAB(m) does not contain an empty string.
We say that the string M = ⟨ej1 ej2 ... ejk⟩ corresponds to the set {M } = {ej1, ej2,..., ejk} 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 N of at most m elements ⟨N SUB(m).
With such designation we define the language PAIR(m).
PAIR (m) = {⟨M ▫ N⟩ / (M  SUBε(m)) & (N  SUBε(m)) & ({M} ⋂ {N } = ∅) & (M N  ∅)}
Note that for any strings M  SUBε(m) and N  SUBε(m), we consider the string ⟨M ▫ N ⟩ to be an ordered pair of strings M and N. Also, for any natural number m,
⟨M ▫ 𝜀⟩ PAIR(m) and ⟨𝜀 ▫ N⟩ PAIR(m)
only with {M } ∅ and {N } ∅.
For convenience, we will use subscripts and superscripts to distinguish between the notation of the substrings included in PAIR(m). That is, for some natural number i, we will use the notation ⟨ MiαMiα̅⟩ for the string ⟨M ▫ N ⟩∈ PAIR(m). Then, for any natural numbers n and m, we define the language d(n, m) over the alphabet Σ2:
d(n, m) = {M1αM1α̅ ⋆... ⋆ MnαMnα̅ ⟩ ̸ ∀i ∈ [1, n] ⟨MiαMiα̅ PAIR(m), and m 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 n and m, holds the following:
1) if ⟨xi1α1... xikαk CLAUSE(n), and the set {xl1β1,..., xlkβk} is any permutation of the set of literals {xi1α1,..., xikαk}, then also ⟨xi1β1,..., xikβk CLAUSE(n),
2) if ⟨cj1 ⋆... ⋆ cjm CNF(n, m), and the set {cl1,..., clm} is any permutation of the set {cj1,..., cjm}, then ⟨cl1⋆... ⋆ clm CNF(n, m).
3) ⟨cj1⋆... ⋆ cjm CNF(n, m) if and only if the clauses corresponding to the strings designated as cj1, cj2,..., cjm form a certain function f, represented in CNF with n variables and with m clauses.
4) if the string ⟨ej1... ejk⟩ ∈ SUB(m) and the set {el1,..., elk} is any permutation of the set {ej1, ..., ejk}, then ⟨el1... elk⟩ ∈ SUB(m).
5) if ⟨M ▫ N⟩ ∈ PAIR(m) then ⟨N ▫ M ⟩ ∈ PAIR(m),
6) if ⟨M1αM1α̅ ⋆... ⋆ MnαMnα̅⟩ ∈ d(n, m) and the set {(Mi1α, Mi1α̅),..., (Minα, Minα̅ )} is any permutation of the set {(M1α, M1α̅),..., (Mnα, Mnα̅)} then
Mi1αMi1α̅ ⋆... ⋆ MinαMinα̅⟩ ∈ d(n, m)
7) ⟨M1αM1α̅ ⋆... ⋆ MnαMnα̅ d(n, m) if and only if the set S = i=1n(MiαMiα̅) consists of m elements and the ordered set of ordered pairs
{({M1α}, {M1α̅}),..., ({Mnα}, {Mnα̅})}, is a special decomposition of the set S, where ⟨Miα⟩ corresponds to the set {Miα} for i ∈ [1, n].
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 . 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 w we will use |w| to denote the number of symbols included in it.
Proposition 3.2. For any natural number n and m, there exist Turing machines TC, TCNF, TSUB, TPAIR and Td that recognize the languages CLAUSE(n), CNF(n, m), SUB(m), PAIR(m), and d(n, m), respectively, in polynomial time.
Proof. (i) Let w 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 .
Let’s describe the general workflow of TC. Receiving the string w, TC does:
(i.1) checks if w starts with one of the symbols x0 or x1,
(i.2) checks whether a binary code follows any occurrence of the symbol x0 or x1.
(i.3) checks if one of the characters x0 or x1, or the special symbol "end of string", follows the binary code. Meanwhile, if TC encounters an "end of string" symbol, it stops.
(i.4) checks whether the index of current literal is less than or equal to n.
(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, TC 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 n, TC accepts only the strings belonging to the language CLAUSE(n) 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 c  |w| for some constant c. Consider the points (i.4) and (i.5):
(i.4) to compare the literal indices with the number n, TC records the number n 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 TC rejects the string w,
2) if the length of index is less than the length of n’s record, then TC records the next literal index on the second work tape and continues working,
3) if the lengths are equal, TC 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, TC rejects the string w, otherwise continues working.
Thus, TC records each index on the second tape, compares its length with the n’s length and compares its digits with n’s digits. So, it needs no more than c  |w| operations for some constant c.
(i.5) let the condition (i.1) - (i.4) be satisfied. This means that the string w has the form
w=⟨xi1α1...xikαk
and TC will check if the binary numbers i1,..., ik are pairwise distinct. It is easy to notice that
|w| =|i1| +... +|ik| +k.
For the point (i.5) TC considers all pairs of literal indices looking for a pair of literals with the same indices: ij = il. So, TC 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, TC moves on to comparing other pairs of indices, otherwise it rejects the string w.
Obviously, TC requires no more than c min(|ij|, |il|) operations for some constant c, to compare the pair of indices ij and il.
It is also easy to prove that the total number of comparison operations of all pairs of literal indices included in the string w does not exceed the number c  (|w|)2 for some constant c.
(ii) Let’s now estimate the complexity of recognizing the language CNF(n, m) for any natural numbers n and m. We describe the general workflow of Turing machine TCNF, that accepts the string w, if w ∈ CNF(n, m) and rejects it otherwise. Receiving the string w, TCNF does:
(ii.1) checks if the number of occurrences of the symbol ‘⋆’ is equal to (m – 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 w:
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(n).
If any of the points (ii.1) - (ii.3) has a negative answer, TCNF rejects the string, otherwise it accepts the string w. It is easy to see that with the described workflow, for any natural number n and m, TCNF accepts only the strings belonging to the language CNF(n, m) 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 c  |w| for some constant c.
With regard to point (ii.3), if (ii.1) and (ii.2) are satisfied, then w looks like
w=⟨cj1cj2⋆...⋆cjm⟩,
where cj1, cj2,..., cjm are clauses. According to point (i.5), these clauses are recognized by Turing machines in no more than
c(|cj1|2+|cj2|2+... +|cjm|2)
operations for some constant c. On the other hand, it is obvious that
(|cj1|2+|cj2|2+... +|cjm|2) (|cj1|+|cj2|+... +|cjm|)2.
Therefore, it is easy to see, that the total number of operations required to accept or reject the string w, does not exceed the number c  (|w|)2.
(iii) The general operating principles of the Turing machine TSAB are similar to those of the TC. To recognize the string of the language SUB(m), TSUB does the following:
(iii.1) checks whether the string w starts with the symbols e,
(iii.2) checks whether a binary code follows any occurrence of the symbol e.
(iii.2) checks whether the current binary code is followed by the symbol e or the special symbol "end of string".
(iii.4) checks whether the number of occurrences of the symbol e is less than or equal to m.
(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, TSUB rejects the string and accepts it otherwise.
Obviously, to accept or reject the string w, TSUB needs no more than c  (|w|)2 operations.
(iv) The general operating principles of the Turing machine TPAIR.
To recognize the string w of the language PAIR(m), TPAIR does the following:
(iv.1) checks whether w consists of two substrings separated by the symbol ‘▫’.
(iv.2) checks whether these substrings are included in the language SUBε(m).
(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 w does not exceed the number c  (|w|)2.
(v) Let’s now describe the general workflow of Turing machine Td that recognizes the string of language d(n, m) in a polynomial time.
That is, receiving the string w, the Turing machine Td runs over it and does:
(v.1) checks if the string w consists of n substrings separated from each other by (n – 1) symbols '⋆'.
(v.2) checks whether each substring is included in PAIR(m).
(v.3) checks whether the number of elements with pairwise different indices in the string w is equal to m.
If any of those conditions is not satisfied, then the Td 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 (n – 1),
2) whether any occurrence of the symbol '⋆' is located between some binary code and the symbol e.
Obviously, the number of required operations does not exceed the number c |w |.
Point (v.2): let |wi| be the number of symbols included in the i-th substring. Then, to check if the i-th substring is included in PAIR(m), Td needs to perform c  (|wi|)2 operations. Since |w1| + |w2| +... + |wn| |w|, then to check if all substrings are included in PAIR(m), Td needs to perform c  (|w|)2 operations.
Point (v.3): if (v.1) and (v.2) are satisfied, then the string w contains elements with binary codes. Receiving the string w, Td does the following:
1) records w on the first work tape, and marks an element in it. Let it be the element ej.
2) records ej on the second work tape.
Td runs over the string w and sequentially compares all non-marked elements in it with the element ej. All elements in that have the same index as ej are marked.
Running through the entire string w, Td continues as follows:
1) records ej on the output tape,
2) looks for the next non-marked element in w 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, Td compares their number with m.
Taking into account the arguments in (i.5), it can be argued that the number of needed operations does not exceed the number c  |w|2.
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 , 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 .
Let we are given a Boolean function f(x1,..., xn) represented in conjunctive normal form with m clauses, and let S = {e1, e2,..., em} be any non-empty tuple of m elements. Recall that we use the notation ej for instead of the string eb(j) of the alphabet Σ2.
To each element of the set S, we associate a clause of the function f(x1,..., xn) so that the element ej = eb(j) corresponds to the j-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 f(x1,..., xn) as S(f) = {e1,..., em} and use these elements as clauses. So, the entry xiαi  ej will mean the inclusion of the literal xiαi in the clause corresponding to ej. Also, the notation ⟨ej⟩ ∈ CLAUSE(n), will mean that the clause corresponding to ej belongs to the language CLAUSE(n) and the string ⟨ej⟩ is formed by the clause ej. So, we designate the following string by fn:
fn=⟨e1e2⋆...⋆em⟩,
Obviously, fn will be the string corresponding to the function f(x1,..., xn) in conjunctive normal form, and f(x1,..., xn) will be a function corresponding to the string fn. To denote the subsets of clauses will be used the capital letters corresponding to the function designation:
For some i [1, n] we form the following sets:
Fi0 = {ej / ej ∈ S(f) and x̅i  ej} and
Fi1 = {ej / ej ∈ S(f) and xi  ej}.
Obviously, Fi0S(f) and Fi1 ⊆ S(f).
Proposition 4.1. If for some natural numbers n and m,
fn ∈ CNF(n, m), then
1) ∀ i ∈ [1, n] ⟨Fi0Fi1 PAIR(m),
2) i=1n(Fi0Fi1) = S(f).
Proof. To proof of (i) it is enough to prove that for any i  [1, n],
1) ⟨Fi0 SUBε(m) and ⟨Fi1 SUBε(m),
2) Fi0Fi1 = ∅,
3) Fi0  Fi1  ∅,
The proof follows from definitions of languages SUBε(m), PAIR(m) and CNF(n, m).
The proof of (ii) follows from the definitions of the sets fMiα and fMiα̅.
Lemma 4.2. For any natural numbers n and m and for any string fn  CNF(n, m), there exists a Turing machine that, receiving the string fn, outputs the string ⟨F10F11 ⋆... ⋆ Fn0Fn1⟩ in polynomial time with respect to the length of the string fn.
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 T1, with input tape, output tape and with two work tapes . The T1’s operation procedure consists of following stages:
Receiving a string of clauses, T1 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 Fi0 and Fi1 for i ∈ [1, n], T1 uses the second work tape, successively recording the pairs (i, 0) and (i, 1) on it. We say that T1 scans a code or a pair of indices, meaning that it scans the symbols that form them.
After recording the numbers of clauses, T1 starts working, recording (1, 0) on the second work tape and 𝜀 on output tape.
Еach action of T1 is determined by configuration of four records on different tapes scanned at current moment. We denote it (H1, H2, H3, H4) with the following meanings:
H1 is current scanned record on input tape,
H2 is current scanned record on first work tape,
H3 is current scanned record of pair (i, 0) on the second work tape, where i ∈ [1, n],
H4 is current scanned record on output tape.
The first configuration is ( xjα, e1, (1, 0), 𝜀), xjα is the first symbol of the string fn, α  {0, 1}.
Аt the beginning of the work, T1 scans these records on the tapes.
To form Fi0 and Fi1, T1 performs actions depending on configuration:
with configuration (x̅i, ej, (i, 0), 𝜀),
1) records ej instead of 𝜀, on the output tape,
2) scans the symbol ej on the output tape,
3) scans the symbol following of x̅i on the input tape,
with configuration (x̅i, ej, (i, 0), ek),
1) adds ej to the output tape and scans it,
2) scans the symbol following of x̅i on the input tape,
with configuration (x̅i, ej, (s, 0), 𝜀) or (x̅i, ej, (s, 0), ek), where i  s,
scans the symbol following of x̅i on the input tape,
with configuration (⋆, ej, (i, 0), ek),
1) scans the symbol ej+1 on the first work tape
2) scans the symbol following of the symbol '⋆' on the input tape,
with configuration (end of input string, ej, (i, 0), ek),
1) adds the symbol ‘▫’ after ek on the output tape,
2) records the pair (i, 1) on the next place following the pair (i, 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 (x̅i, ej, (s, 1), 𝜀) or (x̅i, ej, (s, 1), ek),
scans the symbol following of xiα on the input tape,
with configuration (end of input data, ej, (i, 1), ek) and for i < n,
1) adds the symbol ‘⋆’ on the next place following the ek on output tape,
2) records the symbol 𝜀 on the next place of ‘⋆’ on the output tape and scans it,
3) records the pair (i+1, 0) on the next place following the pair (i, 1) on the second work tape and scans it,
scans the first symbol on input tape,
with (end of input data, ej, (n, 1), ek), the Turing's machine T1 stops.
It is easy to see that T1 outputs the string
F10F11⋆...⋆Fn0Fn1⟩.
Also, the number of actions performed by T1 to complete the described procedure is polynomial with respect to the length of input data of the string fn, denoted by |fn|. More precisely, the number of mentioned operations does not exceed the number c  |fn|2 for certain constant c.
Let's denote by T1(fn) the string formed as a result of T1's work on input fn:
T1(fn)=⟨F10F11⋆...⋆Fn0Fn1⟩.
Lemma 4.3. For any natural numbers n and m,
fn CNF(n,m)if and only ifT1(fn) d(n,m).
Proof. Obviously, if fn  CNF(n, m) then, according to Proposition 4.1 i),
T1(fn) =⟨F10F11⋆...⋆Fn0Fn1d(n,m).
Now, suppose that T1(fn) d(n, m). In this case for any i  [1, n] the following holds:
1) Fi0  Fi1 = ∅, thus, no clause is included in the subsets Fi0 and Fi1 simultaneously.
2) Fi0  Fi1  ∅, that is Fi0  ∅ or Fi1  ∅.
In fact, for any i  [1, n], we get the following:
1) there is no clause including the literals x̅i and xi simultaneously.
2) the literal x̅i is included in some clause or the literal xi is included in some clause.
It means that the number of literals with pairwise different indexes is equal to n.
In addition, each clause ej included in some set Fiα cannot be empty, since if ej  Fiα, then xiα  ej. Therefore fn  CNF(n, m).
We denote by dS(f) the special decomposition of the set of clauses of the function f:
dS(f)={(F10,F11),..., (Fn0,Fn1)}.
If there is a special covering for S(f) in the decomposition dS(f), we denote it as cnS(f) :
cnS(f)={F1α1,F2α2,...,Fnαn}.
For natural numbers n and m, we define the languages satCNF(n, m) and sC(n, m): satCNF(n, m) = {⟨fn⟩ / f is in CNF with m clauses and f is a satisfiable function}, sC(n, m) = {⟨M10M11 ⋆... ⋆ Mn0Mn1 d(n, m)/there is a tuple (α1,..., αn) suchthat
i=1n{Miαi}=i=1n({Mi0}{Mi1})}.
Theorem 4.4. For any natural numbers n and m,
fn satCNF(n,m) if and only ifT1(fn)sC(n,m).
Proof. Suppose that for some natural n and m, fn  satCNF(n, m) and f(x1,..., xn) is the function corresponding to the string fn. According to the definition, f(x1,..., xn) is represented in conjunctive normal form with m clauses and is a satisfiable function. That is, there is a Boolean tuple (σ1,..., σn) such, that f(σ1,..., σn) =1.
We show, that the set {F1σ1, F2σ2,..., Fnσn} is a special covering for the set Sf.
By Proposition 4.1 and Lemma 4.3, it suffices to prove that i=1nFiσi = S(f). Let's show that any clause of the set S(f) is included in some subset
Fiσi⊆{F1σ1,F2σ2,...,Fnσn}
Let there be a clause ej that is not included in any of these subsets. This means that none of the literals x1σ1,..., xnσn is included in the clause ej, and thus ej is a disjunction of some literals of the form x i1-σ i. Since σi1-σi = 0 for any i ∈ [1, n], then for given assignment of variables ej = 0, which contradicts the assumption that f(σ1,..., σn) =1. Therefore, any clause is included in some subset Fiσi that is included in the set {F1σ1, F2σ2,..., Fnσn}, So this set is a special covering for S(f),
i=1n Fiσi=i=1n({Fi0}{Fi1}).
Therefore,
T1(fn) =⟨F1αF1α̅⋆...⋆FnαFnα̅ sC(n,m).
Now assume that for some natural numbers n and m, T1(fn) sC(n, m). This means that T1(fn)  d(n, m) and there are (σ1,..., σn) such that the set {F1σ1,..., Fnσn} is a special covering for the set S(f).
Recall that the literal xiαi is included in all clauses of the subset Fiαi. Therefore, if xiαi = 1, then the value of all clauses in Fiαi, is equal to 1, that is:
for any i  [1, n] and j  [1, m], if xiαi = 1 and ej Fiαi, then ej = 1.
Therefore, if σ1=α1,..., σn=αn, then f(σ1,..., σn) = 1.
Comparing this with the results of Lemma 4.3, that is:
T1(fn) d(n, m) if and only if fn  CNF(n, m),
we obtain that fn  satCNF(n, m).
Remark 4.4.1. According Proposition 3.2, the Turing machine TCNF recognizes the strings of language CNF(n, m) in a polynomial time with respect to the length of string.
Let's for any natural numbers n and m, define the function J1: Σ*Σ* as follows:
J1(w) = TCNF(w), if w CNF(n, m) and J1(w) = ε  ε, if w CNF(n, m).
It is evident, that J1 is a polynomial time computable function with computable time not exceeded the number c  |w|2 for certain constant c.
Also, it is evident, that for any string w  Σ* and for natural numbers n and m,
w  CNFn, m if and only if J1(w) d(n, m).
Recall, that ε  ε  Σ* and ε  ε  d(n, m).
Theorem 4.5. For any natural numbers n and m,
satCNF(n,m)psC(n,m).
Proof. It is obvious that satCNF(n, m) ⊆ CNF(n, m) and sC(n, m) ⊆ d(n, m).
By Lemma 4.2, the Turing machine T1 generates the string T1(fn) in polynomial time for any string fn  CNF(n, m). According to Theorem 4.4 and Remark 4.4.1, for any string w, and for any natural numbers n and m,
fn  satCNF(n, m) if and only if J1(fn) sC(n, m).
Since J1 is a polynomial time computable function, then the language satCNF(n, m) is reduced polynomially to the language sC(n, m).
Now let’s show that the problem of the existence of a special covering is polynomially reducible to the satCNF problem. Let {e1,..., em} be a nonempty set of m elements composed of the alphabet Σ2 as above. Let also ⟨dS⟩ be a string of the language d(n, m):
⟨dS⟩=⟨M10M11⋆...⋆Mn0Mn1d(n,m).
We form the string belonging to the language CNF(n, m), based on the string ⟨dS ⟩.
Let for any element ej  S, L(ej) be the set of literals composed as follows:
L(ej) = {xiαi/ (i∈[1,n]) & (αi  0,1) & (ej {Miαi})}.
In addition, let l(ei) be the clause formed by literals of the set L(ei) and let c(ei) be the string over the alphabet Σ1, which forms by the set L(ei):
c(ej) = ⟨ xi1α1 xi2α2... xikαk ⟩, where any literal belongs to the set L(ej).
We compose the string ⟨ c(e1) ⋆ c(e2) ⋆... ⋆ c(em) ⟩ over the alphabet Σ1, which corresponds to the Boolean function in conjunctive normal form with m clauses, denoted by g(dS) = i=1ml(ei).
It is easy to see, that as a result of formation of all clauses c(ei), the number of literals
in clauses with pairwise different indexes will be equal to n. Therefore,
c(e1)⋆c(e2)⋆...⋆c(em)⟩CNF(n,m).
Lemma 4.6. If ⟨dS ⟩ = ⟨ M10M11 ⋆... ⋆ Mn0Mn1 d(n, m), then the string
c(e1)⋆...⋆c(em)⟩
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 T2, over the alphabet Σ, which time outputs the string
c(e1)⋆c(e2)⋆...⋆c(em)⟩,
when input the string
M10M11⋆...⋆Mn0Mn1⟩.
Let’s consider a Turing machine T2, with input tape, output tape and two work tapes.
The general principles of T2’s operation are as follows:
To form the clause c(ei), it runs over the symbols of input data and with finding the element ei included in Mjαj, adds the literal xjαj to the literals forming the clause c(ei) on the output tape.
At the first stage of work, T2 records pairs of indexes (j, αj) of all subsets Mjαj 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 c(ei) for i [1, m].
In order to generate a clause corresponding to the element ei, T2 uses the second work tape, adding ei on it and scanning ei during the formation procedure c(ei).
After recording the pairs (j, αj), T2 starts work by recording e1 on the second work tape.
To determine each step of T2 it is enough to consider the configuration of three current scanned records on different tapes, which we denote by (H1, H2, H3,):
H1 is the scanned symbol on input tape,
H2 is the scanned pair of indexes on the first work tape of considering subset,
H3 is the scanned element on the second work tape, that is, the element ei if the clause c(ei) is forming.
The first configuration that will be considered to start working over the input data, is
(ek, (1, 0),e1),
where ek is the first symbol of input data.
To form c(ei), the Turing's machine T2 performs actions depending on configuration:
with configurations (ε, (j, αj), ei) or (ek, (j, αj), ei), where k  i,
scans the next symbol on input tape.
with configuration ( ei, (j, αj), ei),
1) adds the literal xjαj on output tape,
2) scans the next symbol on input tape.
with configuration (▫, (j, 0), ei),
1) scans the next symbol on input tape,
2) scans the pair (j, 1) on the first work tape.
with configuration (⋆, (j, 1), ei)
1) scans the next symbol on input tape,
2) scans the pair (j+1, 0) on the first work tape.
with configuration (end of input string, (j, 1), ei) and i < m,
1) adds ⋆ to the output tape,
2) adds the symbol ei+1 to the second work tape and scans it,
3) scans the first symbol of input tape,
4) scans the pair (1, 0) on the first tape,
5) starts to run over the input data again, to detect the element ei+1.
with configuration (end of input string, (n, 1), em), T2 stops.
Obviously, on the output tape we will obtain the string
c(e1)⋆c(e2)⋆...⋆c(em)⟩.
It is easy to see that the number of actions performed by T2 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 c  |dS|2.
Let's denote by T2(dS) the string formed as a result of T2's work on input ⟨dS ⟩:
T2(dS) =⟨c(e1)⋆c(e2)⋆...⋆c(em)⟩.
Obviously, T2 forms the string T2(dS) based on the string ⟨dS ⟩ for any special decomposition dS of the set {e1,..., em}.
Theorem 4.7. For any natural numbers n and m,
dS sC(n, m) if and only if T2(dS) satCNF(n, m).
Proof. Let ⟨dS sC(n, m). This means that the total number of elements with pairwise different indexes in all subsets is equal to m. So, each of the elements e1,..., em is included in some of subsets forming the string ⟨dS ⟩, and there is a Boolean tuple (α1, α2,..., αn) such that
i=1n Miαi=i=1n(Mi0Mi1).
This means that for any element ei  i=1n(Mi0Mi1), there exists a subset
Mjαj∈ {M1α1, M2α1,..., Mnαn} such that ei  Mjαj
On the other hand, if ei  Mjαj then xjαj  l(ei). Thus, the number of forming clauses will be m, which means that the number of strings corresponding to clauses also will be m.
Let's for simplicity denote by gn = T2(dS), that is gn = ⟨ c(e1) ⋆ c(e2) ⋆... ⋆ c(em) ⟩.
Also, we denote by g the function corresponding to the string gn.
Since xj = αj implies xjαj = 1, then (σ1 = α1) &... & (σn = αn) implies
g(σ1,...,σn) =g(dS)(σ1,...,σn) =1.
Therefore, T2(dS) = ⟨ c(e1) ⋆ c(e2) ⋆... ⋆ c(em) ⟩ satCNF(n, m).
Now suppose, that T2(dS) sat CNF(n, m). That is, g is a satisfiable function, which means that for some Boolean tuple (σ1,..., σn), g(σ1, σ2,..., σn) =1.
According to Theorem 4.4,
gn  sat CNF(n, m) if and only T1(gn)  sC(n, m).
Since T1(gn) = ⟨G10G11 ⋆... ⋆ Gn0Gn1⟩, then for some Boolean tuple σ1,..., σn, we obtain
i=1nGiσi=i=1n(Gi0Gi1).
This means that for any clause l(ei), there exists a subset Gjσj such that
Gjσj∈{G1σ1,G2σ2,...,Gnσn} andl(ei)∈Gjσj.
But then ei  Mjσj, because of definition of Gjσj:
Gjσj = {l(ek) / l(ek) ∈ S(g) and l(ek) contains xjσj, ( k ∈ [1, m])}.
At the same time the clause l(ei) contains the literal xjσj only if ei  Mjσj.
Since any element ei determines the composition of one clause, and any clause is defined by one element, then it is easy to prove that for any element ei there exists a subset
Mjσj  {M1σ1, M2σ2,..., Mnσn} such, that ei  Mjσj.
So, i=1n Miσi = i=1n(Mi0Mi1).
Therefore, ⟨ M10M11... Mn0Mn1 sC(n, m).
Remark 4.7.1. According Proposition 3.2, the Turing machine Td recognizes the strings of language d(n, m) in a polynomial time with respect to the length of string. Мore precisely, this time is estimated as c  |w|2, where w is an input string.
Let's for natural numbers n and m, define the function J2: Σ*Σ* as follows:
J2(w) = T2(w), if w d(n, m) and J2(w) = ⟨ εε ⟩ if
wd(n,m).
It is evident, that J2 is a polynomial time computable function with computable time not exceeded the number c  |w|2 for certain constant c.
It is also obvious that for any natural numbers n and m, and for any string w  Σ*,
wd(n, m) if and only if J2(w) CNFn, m.
Recall, that ε  ε  Σ* and ε  ε  d(n, m).
Theorem 4.8. For any natural numbers n and m, sC(n, m) p satCNF(n, m).
Proof. It is obvious that sC(n, m) ⊆ d(n, m) and satCNF(n, m) ⊆ CNF(n, m).
According to Lemma 4.6, for any natural numbers n and m, there is a Turing's machine T2, which for any string
⟨dS⟩=⟨M10M11⋆...⋆Mn0Mn1d(n,m)
forms the string
T2(dS) =⟨c(e1)⋆c(e2)⋆...⋆c(em)⟩
in polynomial time with respect to the length of string ⟨dS⟩. According to the Theorem 4.7 and Remark 4.7.1, for any string w, and for any natural numbers n and m,
dS sC(n, m) if and only if J2(dS ) satCNF(n, m).
Therefore, sC(n, m) p satCNF(n, m).
Since J2 is a polynomial time computable function, then the language sC(n, m) is polynomially reduced to the language satCNF (n, m).
Theorem 4.9. For any natural numbers n and m, the language satCNF (n, m) and the language sC(n, m) 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 NP-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 S = {e1,..., em} be a nonempty set, and let for some Boolean tuple (α1,..., αn),
M1α1, M1α̅1,..., Mnαn, Mnα̅n be arbitrary subsets of the set S such that the set
dnS={(M1α1,M1α̅1),..., (Mnαn,Mnα̅n)}
is a special decomposition of the set S.
Recall that in this case
sM0 = {M1α1,..., Mnαn} and sM1 = {M1α̅1,..., Mnα̅n}.
Definition 5.1. If for some α ∈ {0,1}, the set of α-components of the special decomposition dnS covers the set S, then it will be called a special sMα-covering for the set S.
According to Lemm 1.5 in , there exists a special covering for the set S under the decomposition dnS if and only if for some α ∈ {0,1} there exists an sMα-covering for the set S under some special decomposition IdnS. The search for an sM0-covering in a decomposition dnS consists of finding ordered pairs such that, by permuting their components, the missing elements of the 0-domain are moved to the 0-domain.
Obviously, if the 0-domain of some special decomposition covers the set S, then permutating the components of all ordered pairs of this decomposition, we obtain sM1-covering under another special decomposition and vice versa. So, the notation sMα-covering, will mean that α ∈ {0, 1}.
Definition 5.2. Let dnS be a special decomposition of a set S such that Miαi  sM0 and the 0-domain of the decomposition does not cover the set S.
1) We say that the subset Miαi is an immediate sM0-replaceable subset, if M0 (i)M0.
2) We say that Miαi is an sM0-replaceable subset if it is an immediate sM0-replaceable or, if dnS contains ordered pairs (let i1,..., ik be their indices) such that M0 (i, i1,..., ik) M0.
3) We say that e  S is an sM0-reachable element if there is an ordered pair (Miαi, Miα̅i) such that
(Miαi  sM0) & (eM0)  (eMiα̅i), and Miα is an sM0-replaceable subset. We will also say that the element e is associated with sMα-replaceability of the subset Miαi.
The essence of the concept of sMα-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 Mα-replacement of a subset is an I-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 (τ1,..., τn) and (α1,..., αn), the set
cnS= {M1τ1,...,Miτi,...,Mnτn}
be a special covering for the set S under the special decomposition dnS,
dnS={(M1α1,M1α̅1),..., (Mnαn,Mnα̅n)}.
Then, for any i  [1, n], the subset Miτ̅i is an sMτ̅i-replaceable subset.
Proof. For any i  [1, n], if Mτ̅i  (i) Mτ̅i, then Mτ̅i is an immediate sMτ̅i-replaceable subset. Suppose that for some i  [1, n], the subset Miτ̅i contains elements that are not included in other subsets of the τ̅i-domain. Since cnS is a special covering for the set S, then obviously, for any element e Miτ̅i there is a subset Mjτj such that (Mjτj  cnS) & (e  Mjγj).
Suppose that for some γ1,..., γk  {0, 1}, Mi1γ1,..., Mikγk are the subsets such that
({Mi1γ1,...,Mikγk} cnS) & (Miτ̅i  j=1k Mijτj).
It is obvious that some of these subsets are included in the τi-domain, since by assumption, Miτ̅i is not immediate replaceable subset. Let them be the subsets Mj1β1,..., Mjlβl. That is,
({Mj1β1,...,Mjlβl} cnS)& ({Mj1β1,...,Mjlβl} sMiτi).
Let’s consider the case, when τi = αi. For τi = α̅i, will be a similar proof. In this case, the ordered pair (Miτi, Miτ̅i)  dnS is the same as (Miαi, Miα̅i). But then {Mj1β1,..., Mjlβl}  sMiαi.
Therefore, the subsets Mj1β1,..., Mjlβl are moved to the τ̅i-domain by permutations of the components of the ordered pairs
(Miαi,Miα̅i),(Mj1β1, Mj1β̅1),..., (Mjlβl, Mjlβ̅l).
If some of the subsets Mj1β̅1,..., Mjlβ̅l contain elements that are not included in other subsets in the τ̅i-domain, then by the same reasoning as for the subset Miτ̅i, we find the corresponding ordered pairs and perform permutations of their components.
Since as a result of all permutations new subsets included in cnS move into the τ̅i-domain, this domain will not lose elements. Therefore, Miτ̅i is an sMτ̅i-replaceable subset.
Corollary 5.3.1. Let a special decomposition dnS of the set S be given such that some element e  S is not included in the α-domain of this decomposition, eMα.
If e is not an sMα-reachable element, then there is no special covering of the set S under the decomposition of dnS.
Proof. Follows directly from Theorem 5.3.
Corollary 5.3.2. If there exists a special covering for the set S under the decomposition dnS, then for any i  [1, n] the following is true:
the subset Mi0 is sM0-replaceable or the subset Mi1 is sM1-replaceable.
Proof. Let for some Boolean tuple (α1, α2,..., αn), the set cnS = {M1α1,..., Mnαn} be a special covering for the set S. Obviously, the conditions of Theorem 4.2 are satisfied. So,
for αi = 0, then the subset Mi1 is an sM1-replaceable subset,
for αi = 1, then the subset Mi0 is an sM0-replaceable subset. ∇
In search of sM0-reachability of an element e  S such that (eM0)  (eMiα̅i), 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 {eq1,..., eql} = S \ M0. The elements eq1,..., eql can occur in different subsets in the 1-domain of the decomposition dnS. So, to find a special covering for the set S, we can perform a sequential search for sM0-reachability of each element of the set {eq1,..., eql}:
1) search for ordered pairs that will ensure the sM0-reachability of an element included in the set {eq1,..., eql} under the decomposition dnS, 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 {eq1,..., eql} 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 dnS of the set S. For an ordered set {ei1,..., eil} S, we define a decomposition denoted by dnS0(ei1,..., eil):
(i) if ei1  M0 , then dnS0(ei1) coincides with the decomposition dnS.
(ii) if ei1  M0, then we consider the following two cases:
(ii.1) ei1 is an sM0-reachable element under the decomposition dnS.
In this case, dnS0(ei1) is defined as a decomposition obtained by permuting the components of the ordered pairs that ensure this reachability.
(ii.2) ei1 is not an sM0-reachable element under the decomposition dnS.
In this case, we consider the resulting decomposition as an empty set, dnS0(ei1) = ∅.
(iii) let for some 1 k < l, dnS0(ei1,..., eik) .
If the element eik+1 is included in the 0-domain of this decomposition, then the decomposition dnS0(ei1,..., eik,eik+1) coincides with the decomposition dnSα(ei1,..., eik).
If eik+1 is not included in the α-domain of the decomposition dnS0(ei1,..., eik), then we consider the following two cases:
(iii.1) eik+1 is an sM0-reachable element under the decomposition dnS0(ei1,..., eik).
In this case, dnS0(ei1,..., eik,eik+1) is defined as a decomposition that is obtained by permuting the components of ordered pairs that ensure this reachability.
(iii.2) eik+1 is not an sM0-reachable element under the decomposition dnS0(ei1,..., eik). In this case, we will consider the decomposition dnS0(ei1,..., eik, eik+1) as an empty set.
(iv) if for some 1 k < l, dnS0(ei1,..., eik) = ∅, then also, dnS0(ei1,..., eik, eik+1) = ∅.
Theorem 5.5. Let the special decomposition dnS of the set S be given such that
{eq1,..., eql}=S \M0.
(i) if there exists a special covering for the set S under the special decomposition dnS, and {ej1,..., ejl} is an arbitrary permutation of the elements of the set {eq1,..., eql}, then:
(a)dnS0(ej1,...,ejl) ,
(b) the 0-domain of the decomposition dnS0(ej1,..., ejl) is an sM0-covering for S.
(ii) if dnS0(ej1,..., ejk) = ∅ for an arbitrary ordered set {ej1,..., ejk} consisting of some elements of the set {eq1,..., eql}, then there does not exist a special covering for the set S under the decomposition dnS.
Proof. (i) Let for some Boolean tuple (α1,..., αn), the set cnS = {M1α1,..., Mnαn} be a special covering for the set S under the decomposition dnS. The condition S \ M0 = {eq1,..., eql} implies that cnS sM0 and {eq1,..., eql}  M1. Therefore, for any eqj  {eq1,..., eql}, there is a subset included in cnS, which contains the element eqj.
Let Mi1τ̅1,..., Mikτ̅k, be subsets such that the elements of the set {eq1,..., eql} are located these subsets, where {τ1,..., τk} {α1,..., αn}. In addition,
({Mi1τ̅1,...,Mikτ̅k} M1) & (Mi1τ̅1,...,Mikτ̅k  cnS).
Let for some {τ1,..., τk} {α1,..., αn}, all elements of the set {eq1,..., eql} be located in the subsets Mi1τ̅1,..., Mikτ̅k, in addition,
({Mi1τ̅1,...,Mikτ̅k} M1) & (Mi1τ̅1,...,Mikτ̅k  cnS).
It is easy to see that for any subset Mijτ̅j  {Mi1τ̅1,..., Mikτ̅k} the conditions of Theorem 5.3 are satisfied, which means that the subset Mijτj is sM0-replaceable. Without limiting the generality of the reasoning, we can assume that ej1 Mi1τ̅1. So, as a result of sM0-replacement of the subset Mijτj, we obtain the special decomposition dnS0(ej1) ∅.
Since the transition from the decomposition dnS to the decomposition dnS0ej1 is an I-transformation, then according to Lemma 1.5 in , there exists a special covering for S under the decomposition dnS0(ej1). If the element  ej2 has moved to the 0-domain as a result of an sM0-replacement associated with the element ej1, then according to Definition 5.4,
dnS0(ej1) = dnS0(ej1, ej2) and dnS0(ej1, ej2) .
If  ej2 has not moved to the 0-domain, then by the same reasoning as in the case of the element ej1, there exists a subset Misτ̅s such, that (Misτ̅s  cnS) & ( ej2  Misτ̅s).
By Theorem 5.3, the subset Misτs is sM0-replaceable. Since the replacement is associated with the element ej2, then performing the Mα-replacement of the subset Misτs, we obtain:
1) dnS0(ej1,ej2) ∅,
2) dnS0(ej1,ej2) is a special decomposition,
3) there is a special covering for the set S under the decomposition dnS0ej1,ej2.
Repeating the similar procedure, no more than l times, we obtain:
1) dnS0(ej1,..., ejl) ∅,
2) dnS0(ej1,..., ejl) is a special decomposition,
3) there is a special covering for the set S under the decomposition dnS0(ej1,..., ejl).
It is obvious that when forming the decomposition dnS0(ej1,..., ejl) all elements of the set {ej1,..., ejl} 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 0-domain of the decomposition dnS0(ej1,..., ejl) is an sM0-covering for the set S.
(ii) Now let {ej1,..., ejk}, where k  l, be an ordered set obtained by an arbitrary permutation of arbitrary elements of the set {eq1,..., eql}, such that that dnS0 (ej1,..., ejk) = ∅.
Recall, that dnS0(ej1,..., ejk) = ∅ in the following cases:
(ii.1) dnS0(ej1) = ∅. This means, that under the decomposition dnS there does not exist sM0-replaceable subset, associated with ej1 so, there does not exist a special covering for S.
(ii.2) for some element ejr ( 1 ≤ r < k ),
dnS0(ej1,..., ejr)  dnS0(ej1,..., ejr, ejr+1) = ∅.
This means that under the decomposition dnS0(ej1,..., ejr), there does not exist an sM0-replaceable subset associated with the element ejr+1. But then, by Corollary 4.2.1, there cannot exist a special covering for the set S under the decomposition dnS0(ej1,..., ejr). Since the decomposition dnS0(ej1,..., ejr) is obtained as a result of an I-transformation of the decomposition dnS, then by Lemma 1.5 in , the decomposition dnS does not allow a special covering for the set S. ∇
6. Applications
Let S(f) = {c1,..., cm} be the set of clauses the Boolean function f(x1,..., xn), and let
dnS(f)) ={(F10,F11),..., (Fn0,Fn1)}
be special decomposition of the set S(f).
For a subset S1(f) S(f) and S1(f) ∅, we say that S1(f) is a satisfiable subset if there exists a Boolean assignment tuple (α1,..., αn), such that every clause included in S1(f) evaluates to 1 when assigning values α1,..., αn to variables x1,..., xn.
Theorem 6.1. Let (x1,..., xn) be a function represented in conjunctive normal form with m clauses, and let dnS(f) be a special decomposition of the set S(f).
Then, as a result of any I-transformation of the decomposition dnS(f), the set of clauses S(f) is divided into two satisfiable subsets.
Proof. Let for some Boolean tuple (σ1,..., σn), the set
(r1,...,rp)I (dnS(f)) = {(F1σ1,F1σ̅1),..., (Fnσn,Fnσ̅n)}
be an I-transformation of the decomposition dnS(f). Then, σ1,..., σn will be as follows:
σi = 0, if i  {r1,..., rp} and σi = 1, if i  {r1,..., rp}.
Consider an arbitrary subset in the 0-domain of this decomposition Fkσk ∈ {F1σ1,..., Fnσn}
and the clauses included in it. By definition
Fkσk = {cj / cj ∈ S(f) and cj contains the literal xkσk, j ∈ [1, m]}.
Obviously, if xk = σk then all clauses in the subset Fkσk will take the value 1. So, if x1= σ1,..., xn= σn, 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, (σ̅1,..., σ̅n) will be the satisfying tuple for the 1-domain. Obviously, if S0(f) and S1(f) denote the sets of clauses included in the 0-domain and 1-domain, respectively, then S(f) = S0(f)  S1(f). ∇
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 dnS(f) be a special decomposition generated by the function f(x1,..., xn). Consider an ordered pair (Fi0, Fi1) ∈ dnS(f), assuming that
Fi0 = {cl1,..., clp}and Fi1 = {cj1,..., cjq}.
By the definition of these subsets,
1) the literal  x̅i is included in all clauses of the set {cl1,..., clp},
2) the literal xi is included in all clauses of the set {cj1,..., cjq}.
3) the literals  x̅i and xi are not included in any other clauses.
When permuting the components of the ordered pair (Fi0, Fi1), we obtain the special decomposition (i)I(dnS(f)), in which the i-th ordered pair has the form (Fi1, Fi0). The remaining ordered pairs coincide with the corresponding ordered pairs of dnS(f).
(i)I(dnS(f)) ={(F10,F11),..., (Fi1,Fi0),..., (Fn0,Fn1)}.
We form a function denoted as (i)hI(x1,..., xn) in accordance with Section 3 based on the special decomposition (i)I(dnS(f)). Recall that if
dnS = {(M10,M11),..., (Mn0,Mn1)}
is a special decomposition of a set S = {e1,..., em}, then for any element ej ∈ {e1,..., em}, the clause c(ej) will formed by the following set of literals, {xiαi / ej  Miαi}. Respectively,
(i)hI(x1,...,xn) =j=1mc(ej).
The ordered sets dnS(f)) and (i)I(dnS(f)) differ only in the i-th ordered pair. That is,
Fi0 = {cl1,..., clp} is located in the 1-domain,
Fi1 = {cj1,..., cjq} is located in the 0-domain, of the resulting decomposition.
Let’s denote by c1',..., cm' the clauses of the function hI(x1,..., xn). That is,
S(hI) = {c1',...,cm'}.
Since hI(x1,..., xn) is generated by the decomposition (i)I(dnS(f)), then:
1) for any cjr ∈ {cj1,..., cjq}, the corresponding new clause cjr' will contain the literal  x̅i
2) for any clr ∈ {cl1,..., clp}, the corresponding new clause clr' will contain the literal xi.
Let dnS(hI) = {(H10, H11),..., (Hn0, Hn1)} denotes the special decomposition (i)I(dnS(f)). According to the formation procedure of the function hI(x1,..., xn), we obtain:
1) the literal  x̅i is included in any of the clauses included in Hi0,
2) the literal xi is included in any of the clauses included in Hi1.
At the same time, the clauses of the function (i)hI(x1,..., xn), not included in the subsets Hi0 or Hi1, coincide with the corresponding clauses of the function f(x1,..., xn). Thus, the function hI(x1,..., xn) is obtained by replacing the literal  x̅i with the literal xi and the literal xi with the literal  x̅i in all clauses of the function f(x1,..., xn) containing these literals.
We will say that the function (i)hI(x1,..., xn) is obtained by inverting the literals of the variable xiin the function f(x1,..., xn).
Similarly, the expression (i1,..., ik)hI(x1,..., xn) will mean the function generated by the decomposition (i1,..., ik)I(dnS(f)), for any i1,..., ik  [1, n].
Theorem 6.3. A function f(x1,..., xn) represented in conjunctive normal form is satisfiable if and only if the function (i1,..., ik)hI(x1,..., xn) is satisfiable.
Proof. Let dnS(f)) = {(F10, F11),..., (Fn0, Fn1)} be a special decomposition of the set Sf. Consider the special decomposition (i1,..., ik)I(dnS(f)). By definition,
(i1,..., ik)I(dnSf)) = {(F1σ1, F1σ̅1),..., (Fnσn, Fnσ̅n)},
(σi = 0, if i ∉ {i1,..., ik} and σi = 1, if i  {i1,..., ik}).
Suppose that the f(x1,..., xn) is a satisfiable function, that is, there exists a Boolean tuple (α1,..., αn) such that f(α1,..., αn) = 1. Using the arguments of Remark 6.2 regarding the inversion of literals, it is easy to see that the function {i1,..., ik}hI(x1,..., xn) will be satisfiable by the assignment tuple (β1,...,βn) if we define this tuple as follows:
βi = αi, if i∉ {i1,..., ik} and βi = α̅1, if i {i1,..., ik}.
That is, {i1,..., ik}hI(β1,...,βn) = 1.
Obviously, the opposite is also true.
If {i1,..., ik}hI(β1,...,βn) = 1 for some Boolean assignment tuple (β1,...,βn) then there is a tuple (α1,..., αn) such that f(α1,..., αn) = 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 f(x1,..., xn) 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 dnS(f)) = {(F10, F11),..., (Fn0, Fn1)} be a special decomposition of the set of clauses Sf of the function f(x1,..., xn).
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 hI(x1,..., xn). It is easy to notice, that a function in proportional conjunctive normal form is satisfiable, so by the Theorem 6.3, the function f(x1,..., xn) is satisfiable.
The opposite: Let f(x1,..., xn) be a satisfiable function. Then, there is a Boolean tuple (σ1,..., σn) such that f(σ1,..., σn) = 1. Hence, according to Theorem 4.9, there is a special covering for the set Sf under the decomposition dnSf. Let it be the set cnS = {F1σ1,..., Fnσn}.
1) If the set cnS is an sMα-covering for the set S(f), 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 cq1,..., cql are clauses of the function f such that for some α   {0,1},
{cq1,...,cql}=S(f)\Mα.
Since there is a special covering for the set S(f) then by Theorem 4.4, {cq1,..., cql} is a reachable set. Suppose that {(Fi10, Fi11),..., (Fik0, Fik1)} is the set of replacement steps of the decomposition dnSf that ensure the sMα-reachability of all elements {cq1,..., cql}. After the permutation the components of all these ordered pairs we obtain the special decomposition (i1,..., ik)I(dnSf)). Obviously, as a result, all clauses of the set Sf will be in the α-domain of the resulting decomposition.
Consider the function (i1,..., ik)hI(x1,..., xn) generated by the special decomposition.
(i1,...,ik)I(dnSf)).
Since all clauses of this function are included in the α-domain of the decomposition.
(i1,...,ik)I(dnSf)),
then all they contain a negative literal, if α = 0, or all they contain a positive literal, if α = 1.
This means that, the function (i1,..., ik)hI(x1,..., xn) is represented in proportional conjunctive normal form. At the other hand, the function (i1,..., ik)hI(x1,..., xn) is obtained by inverting the literals of the variable xi1,..., xik in the function f(x1,..., xn).
Thus, if f(x1,..., xn) 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 {eq1,..., eql} not included in the α-domain of the given decomposition, we can search for the sMα-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.
[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.
[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.
[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
  • APA Style

    Margaryan, S. (2026). On Important Applications of Special Set Decomposition. American Journal of Mathematical and Computer Modelling, 11(1), 39-54. https://doi.org/10.11648/j.ajmcm.20261101.14

    Copy | Download

    ACS Style

    Margaryan, S. On Important Applications of Special Set Decomposition. Am. J. Math. Comput. Model. 2026, 11(1), 39-54. doi: 10.11648/j.ajmcm.20261101.14

    Copy | Download

    AMA Style

    Margaryan S. On Important Applications of Special Set Decomposition. Am J Math Comput Model. 2026;11(1):39-54. doi: 10.11648/j.ajmcm.20261101.14

    Copy | Download

  • @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

Author Information
  • Mkhitar Sebastatsi Educational Complex, Yerevan, Armenia