Why Is Satisfiaility Problem Not A NP Problem?

Because by some definition, poynomial time verification is not always satisfied.

To show why, suppose that its 'simplest worst case' format is

f(n) = f1(n) ~ f2(n) ~ ...... ~ fi(n) ...... ~ f(2 ^ n)(n),

where fi(n) is length n-bit CNF and ~ is logic or.

This is the one of the format including all of the possibilities.

You can simplify it but you can not do much, especially

when n become big enough.

You need only check each fi(n) once (length 2) to reject it.

it's always possibe that true answer is also at last: f(2 ^ n)(n),

so you may need 

2 ^ n

(times) operations for this condition verification.

This simplest rejection operation times are indispensible 

for each fi(n) even if it is in the batch omission region,

otherwise you will not know which is which.

So, for itself NP completeness, its time complexity

T(n) > O[(2 ^ n) / n] = exponential time != polynomial time,

because 'dividing by n' take less time than 'n-bit logic operation'.

Even if you can reduce this complexity calculation by half (not possible),

its time complexity is still exponential.

So, Satisfiaility Problem is not a NP problem, based on polynomial

time verification by DTM.

If however you use NDTM solvability as the definition of NP problem,

this conclusion is not valid.

Some people use 3Sat. or kSat. to prove P = NP.

This is not true, they get item m < n as a 'time-wised' factor or 

clause number, such a 3Sat. is far from complete,

because 3 variable clause have far less information than 100 variable clause

Therefore, if you solve a problem of size, say 100, m must be much

greater than n or at least comparable with 2 ^ n.

The greatest problem is that you will never get such a 3Sat. function!

Think of it, if you write one factor one second (very fast),

it will cost you at least 100000 years to simply write out such a 3Sat. function, 

not to say to simplify it! It's simply not possible!

From above reasoning, you will further know that for any size n 3Sat., m >> 2 ^ n must be true,

and if m < n, no clause can be removed in such kSat. function as information deficiency

is the problem and such kSat. representations do not present worst case conditions.

Your implementation need more clauses, not to remove!

You can use computers to generate verification instances, however, for an input size

n = 100, the generation time will cost thousands of years.

For other problems, if you can not use computers to generate test instances, the testing

persons simply can not accomplish such a task!

So solving this problem is not easy at all!

There are many other methods for this, but results are the same.

That's why it is the most difficult problem.

Hope you can really know the true meaning of NP problem.