Where to Simulate Behavior

In this post I am going to describe how behavior does not have to be simulated on the surface; it can be simulated beneath the surface through the interaction of lower level components to produce the desired behavior.

This is most evident in the real world. The real world is built on top of real things, which are themselves built from smaller things, which are built on even smaller things, and so on, possibly to infinity, but more likely ending with strings. For instance, you are made of organs, which are made of cells, which are made of chemicals, which are made of atoms, and so on. And each of these exhibit a behavior which can be simulated in software if its behavior is sufficiently known and software engineering techniques exist to simulate them. While it may not be the case that behavior at all levels can be perfectly simulated, lets assume for my arguments that some day it can be mastered.

Following the example of simulating you, we could attempt to write software that behaves exactly as you do. But we can also write software that behaves exactly as all your organs do, connect them exactly as they are connected in your body, and we will have created something that collectively behaves exactly as you do. We could also write software that behaves exactly as all the types of cells in your body do. Then we could put these cells together exactly as they are put together in the organs in your body. Then connect these exactly as they are connected in your body, and we will have created something that collectively behaves exactly as you do.

This is quite an interesting revelation for me with important implications on how behavior can be simulated. Instead of attacking a complex problem head on and recreate it in software at the top level, if you know details on how the subsystems work and can sufficiently recreate them in software, you can write software to simulate the behavior of lower level components and then link them as the real lower level components are linked to produce the desired top-level behavior.

This introduces a new problem for designing software when this approach is taken. The problem is how to connect and combine the lower level components. This may be more complex than writing software to simulate the top-level behavior. A prime example is in simulating the human brain. People have very good models of neurons and can create software the behaves very close to the real thing. But the wiring of neurons in the brain is so complex nobody has connected digital neurons in such a way that the human brain is simulated through simulating and connecting digital neurons.

But the brain is not a nearly random mass of neurons. While the brain is nearly completely made of neurons, it has been found that neurons form specific components that perform specific functions that are then combined to form higher-level components and so on. Based on my basic understanding, neurons form cortical columns that perform specific functions such as recognize patterns and make predictions. Then these cortical columns form levels of cortical hierarchy that generalize information information going up the hierarchy and localize information going down the hierarchy. Then these levels of cortical hierarchies form functional systems of the brain such as the vision system, auditory system, etc. And finally these are combined to form what we experience as consciousness. (note that when I have been talking about the brain, I have been focusing on the neocortex, which is the brain of our brain where real intelligence occurs).

Based on this structure of the brain, we can attempt to write software to simulate any of these components of the brain such as the cortical columns or levels of the cortical hierarchy. But again, with the brain, it is so complex and so little is known, this is very hard to do. And even when moving up to higher level components it is exceptionally difficult to be able to put these components together to form what we call the brain.

I am still hanging on to the idea that any behavior at any level can at least some day be simulated sufficiently in software, but this is not the case today. But there is another option for simulating behavior when the complexity at the highest level is beyond the capability for direct simulation. If lower-level components are sufficiently known, they can be simulated and combined to form the top level behavior. But there is a trade off, it can be just as hard, if not harder, to combine simulated components than it is to simulate at a higher level.

The real point I am trying to make is that real-world behavior is driven by a hierarchy of components, each of which exhibits behavior that when sufficiently known can some day be sufficiently simulated in software. When attempting to simulate something like the human brain, there are several layers of the hierarchy that can be simulated, not just the top-level of the brain or specific lower-level components such as neurons. There are several layers above and below the actual neurons that exhibit behavior that might be simulatable in software. And when attempting to solve a complex simulation problem like simulating the brain, don’t lock yourself into the obvious paths. Look for and try to understand the hierarchy of components and find the level that make sense for the problem at hand. Some lower-level components might be unnecessary to simulate while some higher-level components might be too complex to simulate. Know that options exist and explore them.

A few final closing questions to clear up some words I’ve used.

What is behavior?

Behavior is observable information. It can be observed via direct human observation or measured via instrumentation. There may be more going on under the hood of the behavior, but I don’t think it matters. If we are trying to simulate the intelligent behavior of the human brain, why should it matter if or how our artificial brain thinks to itself? If for all externally observable and measurable reasons it behaves like a brain, I don’t think it matters what happens on the inside if our only goal is to simulate the intelligent behavior of the human brain. However if you are trying to simulate every neuron and every synapse then it does matter how it works on the inside. This could be the case if you are trying to understand the human brain and/or apply knowledge learned from the simulated brain to the actual human brain.

The point is that when only the top-level behavior is of concern, there is no need to simulate, in software, at any lower level unless a higher-level behavior is too complex or there is something to be learned by lower-level behavior. Because once you simulate, in software, at a particular level, the lower levels become irrelevant and do not exist in the simulation.

What does it mean to simulate?

I’m really using the word simulate in two ways. I have mostly used it to describe the process of creating software that is supposed to act like whatever you are trying to make it act like. In this case the software is directly simulating the desired behavior. This may or may not be the top-level behavior. It is just behavior that is being simulated in software.

The other way I use the word simulate is to describe the end simulation, regardless of whether it is being directly driven by software or whether it is being driven by the interaction of lower-level components. I have heard this called an n-order simulation, or when n > 1, emergent behavior.

Share
  1. Hi Joe! What role, if any, do you see memory taking in simulating behavior?

  2. I think the role of memory is very important. I think memory is what stores the state of the system. For instance, when simulating a ball bouncing, memory stores the environmental boundaries (floor, walls, ceiling, etc) and the state of the ball (position, velocity, direction, etc). And when simulating the human brain, memory plays a more complicated role.

Leave a Comment


NOTE - You can use these HTML tags and attributes:
<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>