We now arrive at the heart of the discussion, the definition of the

complexity class NP as computational problems where you can efficiently

recognize the solution, roughly the same thing is problem solvable is in good

force search. The idea of NP completeness, that the problem can be as

hard as any other problem, where you can efficiently recognize a solution, the

ubiquity of NP-complete problems, including possibly a problem you're

working on right now in one of your own projects, and what should be part of your

toolbox, a simple recipe for proving that problems are NP-complete.

We left off the last video noting that the travelling salesmen problem by virtue

of being solvable in the exponential time using brute force search is certainly not

as hard as notorious problems like the halting problem.

So, perhaps we can instead of mass evidence of interactability for the TSP

by showing it's as hard as any other problem solvable using brute-force

search, that is every other brute-force search solvable problem reduces to

solving the traveling salesman problem. To turn this idea into mathematics we

have to identify the minimal ingredients necessary to solve a problem using brute

force search. And the key idea turns out to be the

efficient recognition of purported solution.

[SOUND] Specifically, we say that a computational problem,

like, say the traveling salesman problem, or frankly almost any other problem we've

talked about in these classes is a member of the complexity class NP if it meets

the following two criteria. The first property is sort of a simple

prerequisite. It is search that solutions have length polynomial in the input size.

The second property, and this is really the key one, is that if someone offers up

to you a purported solution to a NP problem, you can verify its correctness

in polynomial time. To make sense of this abstract

definition, let's think about some concrete examples.

Let's start just with the traveling salesman problem.

So, consider the instance of the traveling salesman problem that's

specified by some n vertices and distances amongst all of the pairs of

vertices. And suppose we want to know whether or

not there's a tour that has a total length.

At most one thousand. So, let's for the moment set aside the

problem of checking whether or not one of the n factorial tours does indeed have

cost of at most 1000. Let's instead think about the much more

modest question, of whether or not a single proposed tour has cost at most

1000. Well, that computational problem is to

verify whether or not a single suggested tour meets the target or not.

That's an easy computational problem, right? The tour is specified just by

order in which you're supposed to visit the vertices.

The length of that ordering is certainly polynomial in the length of the input,

and all you gotta do is add up the n edges that gets traversed in this tour,

and check if this sum is at most 1000 or not.

This argument shows that checking whether or not there exists a tour, with total

cost and most sum threshold, does indeed belong to the complexity class NP.

Right, you can write down a purported solution, in polynomial length. All you

need to do is specify the ordering, and you can verify whether or not a candidate

solution, whether or not a proposed tour meets the threshold in linear time, just

by adding up the corresponding edge costs.

If it bothers you that I moved away from the problem of computing an optimal,

minimum cost tour, and studied instead the seemingly easier problem, I'm just

checking, does there exist a tour that has total cost at most a given threshold,

notice that the former problem reduces to Multiple indications of the latter

problem, just by binary search over the threshold.

The same reasoning can be applied to pretty much all the computational

problems we've seen in these courses, placing all of them into the complexity

class NP. So for the types of problems we've been

thinking about, solutions can generally be specified in linear space, correctness

can be verified in linear time. Another genre of problems that we haven't

really discussed in these classes, but are important in the application domains,

and are also canonical NP problems are constraint satisfaction problems.

In general in a constraint satisfaction problem you have a bunch of variables.

The simplest case would be binary or Boolean variables.

And then you have a list of constraints, and each constraint specifies for a

subset of the variables. a permitted list of configurations of

those variables. So one simple case which some of you've

seen and if you study NP completeness property you'll definitely see it will be

the three set problem. The three set problem does indeed

consider Boolean variables, so each variable xi can either be zero or one and

you can think of the clauses as forbidding a single assignment to a

triple vertices. So a clause might say you are not allowed

to simultaneously assign. X3 to 1, X5 to 0, and X8 to 1.

So clauses for big particular triples of assignments, and the question then is,

does there exist an assignment of all of the variables to 0 an 1, that

simultaneously satisfies all of the constraints.

These kinds of constraint satisfaction problems also belong to the complexity

class in p. So here if you have a purported

assignment of all of the variables to values that meets all of the constraints,

well you can write it down very simply just the value for each of the variables.

And it's easy to check. I just iterate through the constraints

one at a time and see if yes indeed, the values that you're suggesting for the

variables in that constraint are on the list of permissible value combinations.

At the beginning of this video, I suggested that the complexity class NP

would represent problems that are brute force solvable, in the same way that the

traveling salesman problem is. If you look at the actual definition I

just gave you of the class NP, it's in terms of efficient recognition of

solutions, but let's now observe that this definition NP, in terms of efficient

verification of purported solutions does indeed imply that these problems can be

solved in exponential time using brute-force search.

So really, all you do here is check each of the candidate solutions one at a time.

And in doing so, you see very clearly the role of the two properties in the

definition of an NP problem. The role of the first property saying solution length

has to be a polynomial in the input size, in turn, restricts the number of possible

solutions, the number of bit strings of that given length,

to be at most, exponential in the input size.

The second property of course assures you that for each of those only exponentially

many possibilities, you can verify whether or not it is a correct solution,

whether or not it's a short TSB tour, whether or not it's a satisfying

assignment to some variables in a constraint satisfaction problem in

polynomial time. Now because the requirements for the

class NP are so weak, the class NP is very big, where all

membership in NP requires essentially as the ability to officially recognize the

solution. You know one when you see one,

and as you can imagine, that property is met by many of the computational problems

that we ever think about. Factoring almost any graph problems you'd

ever think about, sequencing problems, most constraint satisfaction problems,

and so on. As we've said, it's true that not every,

natural computational problem, is NP. The halting problem is an extreme example.

That's in fact undecidable, there's no algorithm at all. There's also some

natural problems and some application domains which are neither in NP, nor they

undecidable. So, model checking is one domain that

furnishes lots of examples of problems strictly harder than NP.

The vastness of the complexity class NP means that NP-completeness is strong

evidence of intractability. Remember what it means for a problem to

be complete. For some set of problems, it means it's

as hard as any other problem in that set. Every other problem in that set reduces

to the complete problem. Therefore, suppose you had a polynomial

time algorithm for just one, NP-complete problem,

you would get, automatically, by the definition of a reduction, a polynomial

time algorithm for every single computational problem in NP.

Every single problem for which you can efficiently recognize a solution.