A Problem in Power Sets Shows P Does Not Equal NP

1. Introduction

More on terminologies, symbols and notations used in this article can be found in [1] or [2]. Throughout this article, $\mathbb{N}$ will denote the set of positive integers, $\mathbb{W}$ the set of non-negative integers (i.e., $\mathbb{W}=\mathbb{N}\cup \left\{0\right\}$), $\mathbb{Z}$ the set of integers and $\mathbb{R}$ the set of real numbers.

This article is organised as follows: Section 1 deals with some salient points on algorithms, the problem classes P and NP, attempted solutions and feasible solutions. Section 2 presents the power set problem and a decision version of it. Section 3 deals with an algorithm that is instrumental in proving P ≠ NP. Section 4 outlines proof that the power set problem is in NP but not in P. The concluding remarks are in Section 5.

1.1. Algorithms

An algorithm is any well-defined computational procedure that takes finitely many quantities as input and produces finitely many quantities as output. An algorithm is thus a sequence of well-defined computational steps transforming the input into the output [1].

An instance (also called input instance or problem instance) of a problem is an input satisfying all the constraints in the problem statement needed to compute a solution to the problem [1]. For example, suppose the problem is to arrange a given finite sequence of integers in non-descending order of their magnitudes. Then any list consisting of finitely many integers is an instance of this problem. One instance is: 300, 10, -18, 231, -117, 10, -117, 7, 10, 0.

How the size (or length) of the instance is defined depends on the problem $\mathcal{Q}$ being studied [1]. For example, if $\mathcal{Q}$ is the problem seen in the preceding paragraph, then the size of the instance given there is $n=10$ (since all the repetitions have to be counted in). More examples of instances and input sizes are in Appendix A of [3].

A “step” in an algorithm is a primitive operation executed by the algorithm. In dealing with any algorithm, there is a presupposition that every primitive operation to be executed by the algorithm is unambiguously defined. Since we furnish algorithms only in lines of pseudocodes, we adopt the following point of view for the notion of number of steps [1]: we assume that each execution of the $j^{th}$ line of the pseudocode takes $t_j$ steps (meaning, $t_j$ primitive operations).

From a computational point of view, given a problem $\mathcal{Q}$, it is natural to ask if there exists, or can be developed, an algorithm that can process any given instance of $\mathcal{Q}$ to a required extent in such a way that the number of steps taken by the algorithm is bounded by a fixed polynomial in the size of the given instance [4]. Such an algorithm is said to process the input instance in polynomial time (or run in polynomial time; or take polynomial time to process) and is therefore called a polynomial-time algorithm. Note that an algorithm is deemed to run in polynomial time only vis-$\stackrel{‘}{a}$-vis a specified problem $\mathcal{Q}$; in other words, the phrase ‘the algorithm $ALG$ runs in polynomial time’ really means that there is a specified problem $\mathcal{Q}$ such that $ALG$ processes each instance of $\mathcal{Q}$ in polynomial time.

When we say the number of steps taken by an algorithm is bounded by a fixed polynomial in the variable n, what we mean is: there exists a polynomial $f\left(n\right)$ that is fixed for $\mathcal{Q}$ (meaning, in turn, that the instance X of $\mathcal{Q}$ can vary but $f\left(n\right)$ does not, so long as the problem $\mathcal{Q}$ does not) such that given two instances (of $\mathcal{Q}$) of sizes $n_1$ and $n_2$, the number of steps taken by the algorithm is at most $f\left(n_1\right)$ to process the $n_1$-sized instance and at most $f\left(n_2\right)$ for the $n_2$-sized instance.

For the purposes of this article, we consider two types of algorithms: solve-type algorithms (that find a solution, or correctly establish the absence of any solution, to each input instance) and check-type algorithms (that do not find solutions but only check out whether any additional input that is claimed to be a solution to an instance is really so). One crucial difference between these two types is: a solve-type algorithm needs only the instance of the problem as input whereas a check-type algorithm needs the instance as well as an additional input in the form of an “attempted solution” or a “proposed solution”(called so since it might be a solution or not). A solution to an instance is also called a feasible solution. A solve-type algorithm is also called an exact algorithm.

Every algorithm considered in this article is assumed, or if necessary shown to be, correct in the sense that given an input instance, the algorithm halts with an output that is correct [1].

1.2. Certificate Candidates and Certificates

In this article, we consider two classes of problems that are important in the context of algorithms: P and NP. Informally, the class P consists of those problems that are solvable in polynomial time [1,4]. This means to each problem in this class there exists a polynomial-time algorithm that solves each instance of the problem.

The class NP consists of those problems that are “verifiable” in polynomial time [1]. What is meant by calling a problem “verifiable” is that if, in addition to an instance of the problem, we are somehow given a “certificate” of a solution, then we could verify, using a check-type algorithm running in polynomial time, that the “certificate” is indeed a solution, or logically implies (i.e., confirms) the existence of a solution, to the given instance.

It is clear that a certificate is an input component. Also, a certificate only begins as an attempted solution, and might or might not turn out to be a feasible solution [5]. We therefore wish to distinguish between these two situations.

To this end we define a certificate candidate. A certificate candidate is a component that is input along with the problem instance under consideration, the intention (of the user) being to test whether or not the certificate candidate confirms the existence of a solution to the instance. So a certificate candidate is just an attempted solution in the first place.

Let $\mathcal{Q}$ be the problem under consideration, X a problem instance of size n and $C\left(X\right)$ the certificate candidate that accompanies X. The result of running an appropriate algorithm on X and $C\left(X\right)$ will be exactly one of the following three:

• 1.2(i) $C\left(X\right)$ is per se a solution to X (i.e., the attempted solution actually turns out to be a feasible solution).
• 1.2(ii) $C\left(X\right)$ per se is not a solution but it logically implies the existence of a solution, whether or not the implied solution is subsequently made explicit (i.e., the attempted solution, though not a feasible solution by itself, implies the existence of a feasible solution).
• 1.2(iii) Neither is $C\left(X\right)$ a solution nor does it logically imply the existence of a solution.

Henceforth, if any certificate candidate $C\left(X\right)$ obeys 1.2(i) or 1.2(ii), then we will say ‘$C\left(X\right)$yields a solution (to X)’. And by saying ‘$C\left(X\right)$ does not yield a solution (to X)’ we will mean that $C\left(X\right)$ obeys 1.2(iii). Examples to distinguish a certificate candidate obeying 1.2(i) from one obeying 1.2(ii) are in Appendix B of [3].

Next, “checking out” a certificate candidate is different from “verifying” it. To verify a certificate candidate $C\left(X\right)$ is to have a check-type algorithm establish that $C\left(X\right)$ yields a solution to the instance X. If a certificate candidate is thus verified then it is a certificate; else it is just a certificate candidate. If a certificate candidate becomes a certificate, then we will say either ‘the certificate candidate is verified’ or ‘the certificate is verified’. Such a verification is tantamount to saying “YES” to the question whether the instance X has a solution.

On the other hand, to check out $C\left(X\right)$ is to have a check-type algorithm decide whether or not $C\left(X\right)$ yields a solution to X. If the algorithm checking out $C\left(X\right)$ decides that $C\left(X\right)$ does not yield a solution then this decision is tantamount to saying “NO” to the question whether X can be solved with the aid of $C\left(X\right)$. This “NO” is not a conclusive response to whether X has a solution, but only rules that the certificate candidate $C\left(X\right)$ is not a certificate. Thus:

• 1.2(iv) “verifying” requires a certificate candidate that yields a solution to the given instance whereas “checking out” calls for only a certificate candidate that is not required to have any additional properties / features; and
• 1.2(v) an algorithm is deemed to have verified a certificate candidate $C\left(X\right)$ (meaning, $C\left(X\right)$ is deemed to have become a certificate) only when $C\left(X\right)$ is shown (by the algorithm) to yield a solution to X.

So, while a certificate candidate is only an attempted (or, proposed) solution, a certificate is a feasible solution. In other words, every certificate is a certificate candidate in the first place but not every certificate candidate becomes a certificate. Further, a verification of a certificate candidate necessarily begins as an exercise of a check-type algorithm checking out the candidate but every exercise of checking out a candidate need not culminate in verification.

Thus, certificates (feasible solutions) are special cases of certificate candidates (attempted solutions).

As noted in the penultimate paragraph of Subsection 1.1, an algorithm is said to solve an instance X of a problem $\mathcal{Q}$ if the algorithm produces a solution (to X) if one exists or correctly establishes the absence of a solution otherwise, in either case without the need for any certificate candidate. If an algorithm solves each instance of $\mathcal{Q}$ then the algorithm is said to solve $\mathcal{Q}$. An algorithm that solves a problem instance X and an algorithm that only checks out a certificate candidate $C\left(X\right)$ differ primarily in the following aspect: in the former, the input is $\left(X,n\right)$ and the output is a conclusive response to the question of a solution to X while in the latter, the input is $\left(X,n,C\left(X\right)\right)$ and the output is an affirmative or a negative response to the question whether $C\left(X\right)$ yields a solution to X. Note that in each of these cases, finitely many additional input components are allowed.

Now rises the question whether the algorithm that checks out a given certificate candidate does so in polynomial time, for this is crucial in finding out if the concerned problem is in NP. This underlines the importance of the certificate candidate in this context. Given a problem $\mathcal{Q}$, what are needed to decide that $\mathcal{Q}$ can be included in NP? We need: one, a check-type algorithm - call it $AL\left(\mathcal{Q}\right)$ - and two, to each instance X (of $\mathcal{Q}$), a certificate candidate $C\left(X\right)$ that is verified by $AL\left(\mathcal{Q}\right)$ in polynomial time (in n, the size of X).

1.3. Remarks on Algorithms Recognizing Feasible Solutions

An algorithm is said to recognize a feasible solution if the algorithm verifies that the input certificate candidate is a certificate. In the context of NP, such recognition needs to be done in polynomial time.

Let X be an instance of a problem $\mathcal{Q}$ and $ALG$ be the algorithm designed to check if an input certificate candidate is a certificate. Let $C_1$ and $C_2$ be two distinct certificate candidates.

Suppose that both $C_1$ and $C_2$ are feasible solutions to X. Then it is desirable that $ALG$ recognizes $C_1$ or $C_2$, whichever is input with X. However, owing to the design of $ALG$ the following might ensue:

• 1.3(i) $ALG$ recognizes the feasible solution $C_1$ in polynomial time and
• 1.3(ii) $ALG$ fails, or takes worse than polynomial time (perhaps, exponential or factorial time [1,6]), to recognize the feasible solution $C_2$.

Then $C_2$, despite being a feasible solution, is not useful in deciding if $\mathcal{Q}$ is in NP. So only candidates that can be checked out by the algorithm in polynomial time should be used. To aver that $\mathcal{Q}$ is in NP, for each instance of $\mathcal{Q}$ we only need one candidate that $ALG$ recognizes as a feasible solution in polynomial time, even if there exist other feasible solutions that $ALG$ does not recognize at all or does not recognize in polynomial time.

1.4. Looking for Certificates

If a problem $\mathcal{Q}$ is given, then it is not difficult to come up with an instance X of a desired size n and a certificate candidate. But the same cannot be said for a certificate, even if an algorithm is available. Then how can a certificate, if at all one exists, be obtained?

Recall the part of the informal explanation of the class NP that goes ‘...if, in addition to an instance of the problem, we are somehow given a “certificate” of a solution, then we could verify...’ (in the second paragraph of Subsection 1.2). The operative word there is ‘somehow.’ This clearly indicates there are no hard and fast rules as to the source of a certificate candidate or its form or the process of obtaining it; only every certificate candidate must rest on irrefutable theory that is relevant to the problem. Indeed, given an arbitrary problem instance, it is not known how to identify a certificate [5]. So it is not known how to identify a certificate candidate that will turn out to be a certificate. A certificate candidate $C\left(X\right)$ could be readily available (i.e., prepared beforehand by someone) or could be compiled as and when the need arises. Preparing $C\left(X\right)$ could take any amount of time - polynomial or worse. But the time to prepare $C\left(X\right)$ will not be included in the time required for the algorithm to check out $C\left(X\right)$. This is because whoever prepares $C\left(X\right)$ is allowed to do any immense amount of calculation beforehand, and only the results of that calculation need be written on $C\left(X\right)$ [6].

In any quest for finding out whether a problem is in NP, one assumption (on the quester’s part) is that given an instance of the problem there is a non-vacuous class of certificate candidates corresponding to this instance.

1.5. Remarks on P and NP

The class P is contained in the class NP [1,4]. But it is not known whether these two classes are the same - and this is the crux of the famous problem “Is P = NP?” (also called the “P versus NP” problem).

One approach to this problem is trying to prove NP is contained in P; this, if successful, gives P =NP. An opposite approach is finding or formulating a problem that falls in NP but cannot be in P (thereby establishing P≠ NP), even if such a problem is artificially formulated [7].

Any problem in NP can be solved by exhaustive search (also called perebor, meaning “brute-force search” [7]). But steps in exhaustive search grow to forbiddingly large numbers even for a moderate growth in the size of the instance. Though decades of extensive efforts to settle the P versus NP question have produced algorithms that take significantly fewer steps than exhaustive search for problems in NP, an exact polynomial-time algorithm for any of these problems is yet to be. As a consequence, it is now commonly believed that P ≠ NP [8].

1.6. Atomic Sub-Outputs

Let S be a solution to a problem instance X. Suppose S consists of finitely many definite and distinguishable objects $Y_1,∆,Y_k$ (for some $k\in \mathbb{N}$) that are to be computed in a sequence. Then each of these k objects is an atomic sub-output of S.

For example, if the problem is to compute the set of all positive integers q less than a given positive integer m such that q is a perfect cube, then the set $S=\left\{1,8\right\}$ is a solution to the instance $m=20$ of this problem. Each of the two elements of S is an atomic sub-output of S. S is the only solution to the instance $m=20$. The instance $m=1$ has no solution.

Now consider a problem $\mathcal{Q}$ such that:

• 1.6(i) each instance of $\mathcal{Q}$ has a solution and
• 1.6(ii) each solution to a given instance (of size n) of $\mathcal{Q}$ consists of $m^n$ atomic sub-outputs (to be computed in a sequence) for some $m\in \mathbb{R}$ with $m>1$.

Any algorithm that outputs a solution to a given instance of $\mathcal{Q}$ has to compute all the $m^n$ atomic sub-outputs that the solution comprises. Then as the instance size n increases, the number of steps taken by an algorithm cannot be bounded above by any polynomial in n (see Proposition 2.4 in [3]). Consequently, if $\mathcal{Q}$ is in NP then it follows immediately that P≠NP. To confirm that $\mathcal{Q}$ is in NP, we need a check-type algorithm - call it $AL\left(\mathcal{Q}\right)$ - such that to each instance X of $\mathcal{Q}$ there must be obtainable at least one certificate candidate $C\left(X\right)$ that is verified by $AL\left(\mathcal{Q}\right)$, in polynomial time, to yield a solution to X. Such a $C\left(X\right)$ can be obtained from anywhere or prepared anyhow but once it is input along with X and n then from that point $AL\left(\mathcal{Q}\right)$ should need to do only a polynomial amount of computations to verify $C\left(X\right)$ [6].

We discuss such a problem and the necessary verifications (using polynomial-time algorithms) in Section 2 through Section 4. The problem is centred on the power set of a nonempty finite set.

1.7. Remarks on Capabilities of Algorithms

There are computational capabilities algorithms are known to possess, and literature abounds with discussions on such capabilities. And there are capabilities that supposedly cannot be possessed by any algorithm, at least as of now. For instance, to date there is no known algorithm with the capability to carry out exhaustive search in polynomial time for an arbitrary input. Discussing these capabilities is not in the scope of this article. Suffice it to say that facts / suppositions about capabilities of algorithms rest on established theories. These theories may advance and then there may come along algorithms with new / enhanced capabilities. We deal with the P versus NP problem in the framework of capabilities of algorithms at present.

In the preceding discussions, only informal definitions of algorithm, P and NP have been used. Their formal definitions are in [1,4].

2. The Power Set Problem for Nonempty Finite Sets

A set is a collection of definite and distinguishable objects [1,2]. Each object in a set is an element or a member of the set. It is taken for granted that if X is a given set then there is a well-formed definition that decides conclusively whether or not two given elements of X are distinct. Also, such a definition is made explicit when necessary. There is a unique set that contains no members, and this is the empty set, denoted by $\varphi$.

The cardinality (or, size) of a set X is the number of elements in X, and is denoted by $\left|X\right|$. Obviously $\left|X\right|\ge 0$. If $\left|X\right|\in \mathbb{W}$ then X is a finite set; else X is an infinite set.

The set of all the subsets of a set X, including the empty set $\varphi$ and the set X itself, is denoted by $\mathcal{P}\left(X\right)$ and is the power set of X. If X is finite of cardinality n then $\mathcal{P}\left(X\right)$ is finite [1,2] of cardinality $2^n$.

A variant of a problem $\mathcal{Q}$ is a formulation of $\mathcal{Q}$ that seeks a desired type of solution without altering the import of $\mathcal{Q}$. Types of variants that are widely studied and used are: optimization, computation and decision.

An optimization variant of $\mathcal{Q}$ is a formulation of Q that asks for a solution of an optimum measure (which is either the maximum or the minimum of the concerned measure) to each instance of $\mathcal{Q}$ [9].

A computation variant of $\mathcal{Q}$ is a formulation that asks for a solution (to each instance of $\mathcal{Q}$) subject to finitely many conditions.

A decision variant of $\mathcal{Q}$ is a formulation of $\mathcal{Q}$ using a decision question that asks for either a “yes” or a “no” answer to each instance. The basic ingredients [9] of a decision variant are: the set of instances, the set of attempted solutions (i.e., certificate candidates) and the predicate that decides whether an input certificate candidate yields a solution.

The power set problem for nonempty finite sets is: given a nonempty finite set X, find $\mathcal{P}\left(X\right)$. This statement also represents an optimization variant of the problem. Here the measure considered is cardinality of sets, and the optimum measure is the maximum cardinality.

We name this problem $\mathcal{P}\left(FIN\right)$. Any instance of $\mathcal{P}\left(FIN\right)$ is a nonempty finite set X, and the input size of this instance is $\left|X\right|$. If some subset $\mathcal{L}$ of $\mathcal{P}\left(X\right)$ has been output, then each member of $\mathcal{L}$ is an atomic sub-output of $\mathcal{L}$.

In the context of the P versus NP problem, we shall be concerned with optimization and decision variants only. It is common to formulate an optimization problem $\mathcal{Q}$ as a decision problem to find out if $\mathcal{Q}$ is in NP.

2.1. A Decision Variant of $\mathcal{P}\left(FIN\right)$

Inputs: (i) A nonempty finite set X (the problem instance),

(ii) $n=\left|X\right|$ (the size of the instance) and

(iii) $k\in \mathbb{Z}$.

Question: Is there a set $\mathcal{L}$ such that $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$ with $\left|\mathcal{L}\right|=2^k$?

Certificate candidate:$C\left(X\right)=k$, with k as in (iii) of the list of inputs above..

Output: YES (meaning, exists $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$ such that $\left|\mathcal{L}\right|=2^k$) or NO (no such set $\mathcal{L}$ exists), as appropriate.

Note. It is mandatory that the inputs 2.1(i) through 2.1(iii) and $C\left(X\right)$ be free from any error, as also that they be logically consistent with one another.

In Section 3, we outline an algorithm (in pseudocodes) that we name CHECKSUBSET and prove what are required to verify that $\mathcal{P}\left(FIN\right)$ is in NP.

3. Algorithm CHECKSUBSET

The following algorithm will be referred to as CHECKSUBSET. The input is $\left(X,n,k,C\left(X\right)\right)$. X, n, k and $C\left(X\right)$, as well as the decision question and the required output, are given in Subsection 2.1.

Algorithm CHECKSUBSET

BEGIN

1. if $0\le k\le n$

2. then print “YES, exists $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$ with $\left|\mathcal{L}\right|=2^k$” and STOP

3. else print “NO. No set $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$ can have $\left|\mathcal{L}\right|=2^k$” and STOP

4. endif

STOP

Note: In the above pseudo-code, excluding BEGIN and STOP, the instructions have been numbered 1 through 4. The numbered instructions will be referred to as line 1 through line 4.

Proposition 3.1.

Let $C\left(X\right)=k\in \mathbb{Z}$ be the certificate candidate corresponding to the input instance X in the algorithm CHECKSUBSET.

• (i) If $0\le k\le n$ then $\left|\mathcal{L}\right|=2^k$ for some $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$.
• (ii) If $k<0$ or $k>n$ then there is no set $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$ such that $\left|\mathcal{L}\right|=2^k$.

Proof. 

(i) Write $X=\left\{x_1,\cdots ,x_n\right\}$. Let $A=\left\{x_1,\cdots ,x_k\right\}$ and $\mathcal{L}=\mathcal{P}\left(A\right)$. Then $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$ and $\left|\mathcal{L}\right|=2^k$.

(ii) Suppose $k<0$. Then no set $\mathcal{L}$ can satisfy $\left|\mathcal{L}\right|=2^k$ since $0<2^k<1$. If $k>n$ then $\left|\mathcal{L}\right|\le 2^n<2^k$ whenever $\mathcal{L}\subseteq \mathcal{P}\left(X\right)$, from which the conclusion follows. •

Proposition 3.2.

The algorithm CHECKSUBSET is feasible (i.e., terminates in a finite number of steps) and correct.

Proof. 

The certificate candidate is $C\left(X\right)=k\in \mathbb{Z}$. The algorithm makes decisions based on whether or not $0\le k\le n$ (line 1). This check comprises the checks $0\le k$ and $k\le n$, each of which clearly terminates in a finite number of steps.

Each output returned by the algorithm is either YES or NO. The possible outputs are all accounted for in two lines of the algorithm - namely, lines 2 and 3. So the algorithm returns only finitely many outputs. Printing each decision clearly terminates in a finite number of steps.

Consequently, CHECKSUBSET is feasible. Next, we prove its correctness.

If $0\le k\le n$ is true then the algorithm decides YES (line 2), which is the correct output by Proposition 3.1(i). If $0\le k\le n$ is false then the algorithm decides NO (line 3). This is the correct output by Proposition 3.1(ii). •

Proposition 3.3.

Given an input $\left(X,n,k,C\left(X\right)\right)$, CHECKSUBSET runs in polynomial time in n.

Proof. 

The total number (say, T) of steps executed by the algorithm CHECKSUBSET is the sum of the numbers of steps for all the lines executed. Suppose that one execution of the line j requires $s_j$ steps and that this line is executed exactly $q_j$ times. Then $s_j{q}_j$ is the number of steps consumed by the line j in one execution of the algorithm.

In one execution of the algorithm, each line is executed once if at all. Hence, for $j=1,\cdots ,4$, $s_j{q}_j=s_j$.

We suppose each endif line takes constant time, independent of n.

Line 1 comprises the checks $0\le k$ and $k\le n$. The number of steps required for each of these checks is bounded above by $n^2$. Likewise for line 2 as well as line 3. Consequently, $T\le 4n^2+1$. •

Proposition 3.4.

To each instance X of $\mathcal{P}\left(FIN\right)$ there is a certificate that is verified by CHECKSUBSET in polynomial time in the size (n) of X.

Proof. 

$C\left(X\right)=k\in \mathbb{Z}$ (where $0\le k\le n$) is such a certificate. The polynomial-time verification holds by dint of Proposition 3.3. •

4. $\mathcal{P}\left(\mathbf{FIN}\right)$, the Class NP and the Class P

Proposition 4.1.

$\mathcal{P}\left(FIN\right)$ is in NP.

Proof. 

Let X be a given instance of $\mathcal{P}\left(FIN\right)$ with $\left|X\right|=n$. The next requirements are a check-type algorithm and a certificate candidate that is verified in polynomial time by this algorithm to confirm the existence of a solution to X.

The required algorithm is CHECKSUBSET (Section 3) and an appropriate certificate candidate is $C\left(X\right)=k\in \mathbb{Z}$ with $0\le k\le n$ (Proposition 3.3 and Proposition 3.4). •

Proposition 4.2.

$\mathcal{P}\left(FIN\right)$ is not in P.

Proof. 

Let $ALG\mathcal{P}\left(FIN\right)$ be a given feasible algorithm that solves $\mathcal{P}\left(FIN\right)$. Given an instance X with $\left|X\right|=n$, the solution to this instance is $\mathcal{P}\left(X\right)$, and each of the $2^n$ distinct members of $\mathcal{P}\left(X\right)$ is an atomic sub-output of this solution. Name these sub-outputs $S_1,\cdots ,S_q$ in the order that $ALG\mathcal{P}\left(FIN\right)$ follows in the process of computing $\mathcal{P}\left(X\right)$. Clearly $q=2^n$.

For $j=1,\cdots ,q–1$, having taken $s_j$ steps for only the computation of $S_j$, suppose $ALG\mathcal{P}\left(FIN\right)$ takes another $s_{j+1}$ steps to compute $S_{j+1}$; in other words, once $ALG\mathcal{P}\left(FIN\right)$ executes $s_j$ steps to compute $S_j$ then beginning with the next step $ALG\mathcal{P}\left(FIN\right)$ executes $s_{j+1}$ steps to compute $S_{j+1}$, allowing that any of the already-computed sub-outputs $S_1$ through $S_j$ may be used anywhere in the computation of $S_{j+1}$ Obviously, then, each $s_j\ge 1$ and $s_q\ge 1$.

If $T\left(X\right)$ is the total number of steps taken by $ALG\mathcal{P}\left(FIN\right)$ to compute the subsets $S_1$ through $S_q$, then $T\left(X\right)\ge s_1+\cdots +s_q\ge q=2^n$. Consequently, $ALG\mathcal{P}\left(FIN\right)$ cannot run in polynomial time. •

5. Conclusions

P ≠ NP follows from Proposition 4.1 and Proposition 4.2.

There is a caveat, though. The optimization variant of the problem $\mathcal{P}\left(FIN\right)$ requires computations that take exponential number of steps, as can be gauged from the proof of Proposition 4.2, leading to a thought that no algorithm is likely to possess the capability to compute exponential (or worse) number of atomic sub-outputs of the solution to any instance of $\mathcal{P}\left(FIN\right)$ in polynomial time. But what if underlying theories get advanced sufficiently so that an algorithm with this capability is designed? Would it (or, rather, would it not) imply that exhaustive search could be done in polynomial time? Then would P = NP ensue? This is a moot point. However, at present, surveys ([8], for one) seem to favour the opinion that no algorithm is ever likely to have such a capability. This seems to justify the conclusion that P ≠ NP.