_{1}

^{*}

The paper proposes a logical model of combinatorial problems; it also gives an example of a problem of the class NP that cannot be solved in polynomial time on the dimension of the problem.

Suppose we have a n-set

Logic is the natural language of mathematics. Therefore, the construction of logical models of combinatorial problems helps to better understand the features of a problem, estimate the possible ways and the complexity of the solving.

Any mass problem is characterized by some lists of parameters (in our case, this is the set A) and by predicate P(S), which determines the properties of the solution S [

The problem belongs to the class NP if the solution can be checked for the time described by a polynomial

The purpose of this paper is to offer a general logical model of combinatorial problems, the solution of which is a disordered sample, as well as to estimate the complexity of solving certain problems.

Usually, each combinatorial problem is defined as a triple (A, P(S), W(S)), where

Each subset

Thus, the combinatorial problem can be represented as the three: (A, f(B), W(B)), where W(B) = W(S).

Example 1. (The maximum independent set problem). Let there be an undirected graph

It is obvious that here A = V is the set of solution elements, the predicate P(S) is defined by a procedure that determines whether a subset of vertices

We associate each subset

We associate each vertex

is the desired pointer of feasible solutions f(B).

Thus, the solution to the problem is to find a tuple B, which has the maximum number of unities, on which the function f(B) equals to one (true).

For example, suppose, there is the undirected graph

We associate each vertex

So, we must find the values of Boolean variables

is maximum provided that the Boolean function

Example 2. (The Hamiltonian cycle problem). Let there be an undirected graph

It is obvious that here A = E is the set of solution elements―the set of graph edges. Predicate P(S) defines procedure that determines whether the basic condition of Hamiltonian graph is executed, namely, a subset of edges

In this case it is convenient initially to construct a function

We associate each edge

The function

conjunctions in the form

which correspond to tuples containing three edges that incident to the same vertex. Obviously, one should not write conjunction with more than three variables, as they are absorbed by conjunctions of the three variables.

Writing down all such conjunctions for vertices with local degree equals to or more than three, we obtain the inverse function for PFS. For the graph shown in

Therefore, the function

Hence, we have the final form for the pointer of feasible solutions:

As for the function W(B), then it is given by the procedure which establishes that the considered subgraph is a Hamiltonian cycle. This can be executed by depth-first search (DFS) in the graph.

Example 3. (The satisfiability problem). In the satisfiability problem, some Boolean function

Obviously, in this case literals of Boolean variables are the elements of the solution, that is, the variables

The cost function is defined by the given Boolean function, that is,

In the process of solving the problem, we have two stages:

• Input of initial data of the problem;

• The proper stage of solving the problem.

The number of symbols, which is required for recording initial data, is the dimension of the problem. To solve the problem, it is obviously necessary at least once “view” all of its initial data. Therefore, the complexity of solving any problem cannot be less than O(n), where n is the dimension of the problem. An example of such a problem can be a problem to find the maximum element of the array M.

In principle, the problem of the search of the maximum element of an array (PME) M can be represented in the form of our logical model. For example, the binary address of the cell of the array can be considered as a set of abstract Boolean variables. The pointer of feasible solutions in this case is a constant 1. The cost function is given by the comparison procedure given numbers. Clearly, to solve this problem, it is necessary to consider all elements of the array, since we do not know how its values of these elements are arranged in an array.

Next, we consider the following example.

Let there be a Boolean tuple of length 4 (a tetrad)_{1} + w_{2} + w_{3} + w_{4}―a weight of the tetrad X. Summands

• if x_{1} = 0 then w_{1} := 5 else w_{1} := 13;

• if x_{1} = 0 and x_{2} = 0 then w_{2} := 7;

• if x_{1} = 0 and x_{2} = 1 then w_{2} := 10;

• if x_{1} = 1 and x_{2} = 0 then w_{2} := 12;

• if x_{1} = 1 and x_{2} = 1 then w_{2} := 4;

• if x_{3} = 0 then w_{3} := 3 else w_{3} := 8;

• if x_{3} = 0 and x_{4} = 0 then w_{4} := 2;

• if x_{3} = 0 and x_{4} = 1 then w_{4} := 15;

• if x_{3} = 1 and x_{4} = 0 then w_{4} := 3;

• if x_{3} = 1 and x_{4} = 1 then w_{4} := 17.

We assume that the values of the summands_{1} + w_{2} + w_{3} + w_{4}.

Also suppose that there is a pointer of feasible solutions

It is easy to see that we have an equilibrium Boolean function, that is, on half of tuples, this Boolean function equals to 0, and the other half equals to 1. The formula for calculating the given Boolean function (the pointer of feasible solutions) has the form:

Let it be required to find a tuple X of the maximum weight at which f(X) = 1.

In general, the considered problem (we call it as “Heavy tuple (HT)”) can be formulated as follows.

Suppose we have n Boolean variables

In addition, let be the given the equilibrium Boolean function

It is required to find a tuple

The same problem in the decision form was formulated in [

Theorem 1. The problem “Heavy tuple” cannot be solved in polynomial time on the dimension of the problem.

Obviously, the problem HT is formulated as an analogue of the problem of finding the maximum element of the given array (PME).

In fact, in the problem “Heavy tuple”, addresses (binary tuples) of the array of feasible solutions are determined by the pointer of feasible solutions f. Calculation of the address in this case can be performed by brute force only, because otherwise we have a problem searching for the function

Assuming that we can calculate the tuple S, where there is the maximum weight. However, such tuple may not be the feasible solution, as the pointer f(S) = 0. Since we do not know the predicate P(S) explicitly, this does not allow considering other ways to solve the “preview” of all elements of a given array of feasible solutions, the number of which is not less than

Corollary 1. The class P does not coincide with the class NP, that is, P É NP.

The proposed combinatorial model allows considering not only the well-known combinatorial problems, but also considering new problems such as “Heavy tuple” with single point of view. The most important consequence of the proposed model is to establish the inequality of classes P and NP on the example of the problem “Heavy tuple”. The conclusions, obtained in the study of this problem, cannot be extended to problems, considered in Examples 1-3, as predicate P(S) explicitly specified in them.

Anatoly D. Plotnikov, (2015) On a Logical Model of Combinatorial Problems. Open Access Library Journal,02,1-6. doi: 10.4236/oalib.1101479