In order to be able to build an agent based model of team problem solving, we need a model for problem solving itself. To address this challenge, researchers draw on something called NK space, which is a model for complex problem solving, inspired by evolutionary models of genetic combination. Although the mathematical details of NK space are more complex than the material we're going to cover in this video, the intuition behind the idea is very simple. In genetic evolution, every new organism is very similar to its parents, with only a few small changes known as mutations. What is important about the process is that a mutation never changes an entirely organism at once. Rather, it works with the machinery that already exists and just changes one or two things at a time. So imagine you're an engineer working on a problem. For example, suppose you're trying to build a rocket to transport goods to the International Space Station. Now, you're not going to build a rocket from scratch, you're going to start with an existing model. Simalarily to genetic evolution, it's not feasible for an engineer to change every feature of the rocket at once. This would be no better than building a rocket entirely from scratch. So the engineer changes just one or two features and then evaluates whether the new design is better or worse than the old one. This then, is the essential process that is captured by an NK space model. Complex problem solving can be broken down into an iterative process where decisions are made by just changing one or a small number of features from a previous version. If the change is good, the new design is kept. Otherwise, we revert to the old design. Now, there's one more important thing to keep in mind. Features are not independent. Rockets are complex systems. And if you change one feature, that can impact how all the other features function. Suppose, for example, you want to increase the speed of the rocket by increasing the size of the fuel tank. This will also end up making the rocket heavier. And you might have to move some some things around to make space for the increased size of the fuel tank. This interdependence between features is why complex problem solving is hard. So how do we make this into a formal model? Imagine that a rocket can be divided into six different discrete features, engine fuel tank, fuel type, cockpit, cargo bay, and landing gear. The N in the NK space refers to the number of features. In this case, our problem has 6 features and therefore, N = 6. The K refers to the level of interdependency and counts how many other features each feature interacts with. When k = 1, every feature interacts only with itself and every feature is therefore independent. In this example, that would mean, hypothetically, that you could change the fuel tank size without any impact on the other features of the rocket. In fact, when k = 1, problems are very simple to solve because you can simply try every version of every feature until you find the best solution. However, when k is greater than 1, problems are complex. It's the interdependencies between features that are precisely what make problems difficult to to solve. So what does all this mean for problem solving? One very common way of representing a problem in NK space is to represent it as existing on a solution landscape. Now, a solutions landscape might look a little something like this. And it's important to keep in mind that this is just a two-dimensional representation of a multi-dimensional space. It's just a representation. The idea, however, is that as you change features of a design, one feature at a time, you slowly move along the solution landscape. Because each design must be very similar to the one preceding it. It can only move to adjacent points on the landscape. For very simple problems, for example, when K = 1, a solution landscape is often represented like this. The x-axis represents different possible combinations of the various features of the problem. The y-axis represents the fitness or the quality of each particular solution. Because you can change each feature in this simple landscape without any interdependency on other features, you can simply change them one at a time. Moving along the landscape until you find the best solution. Now, we're, of course, interested in complex problems. That is, when k is greater than1. And in those cases, a solution landscape is represented like this. Now again, the x-axis represents different possible combinations of the various features in the problem. And the y-axis represents the fitness or quality of each particular combination. Now, however, the landscape looks very different from our simple problems. This landscape, the roughness of this landscape, represents the fact that a change in one feature may have unexpected interactions with other features. As this illustration shows, you still change only one feature at a time, slowly moving along the landscape. Now, suppose we get to this point of the landscape after changing our features. Where do we go from here? The challenge in complex problem solving is that it's easy to get stuck in what's called a local maximum or a local optimum. The only way to get any further improvement after you've reach this point in the design space would be to change many features at once. In other words, we would need to jump to an entirely different part of the solution landscape in order to find anything better. So you might be asking yourself, why don't people just jump to the highest part of the landscape. Remember, in real life, we don't actually have a map of the full landscape. So making big changes, changing a lot of features at once, is really risky. Suppose, for example, an engineer working on a rocket were to suddenly change many features all at once. It could place them on a higher peak and give them a better solution. It could just as likely give them a lower quality solution, leaving them worse often than they were before. It could also give them a lower quality solution, but place them at the base of the highest peak. That would be good thing, but the problem is that you don't know when you're on the base of a local maximum and when you're on the base of a global maximum. This is why complex problem solving is represented as a slow, iterative process, changing one feature at a time. And that's how we model complex problems in NK space.