The Four Levels of SCL “Intelligence”

By Eugene Asahara

Created: April 25, 2008

Last Updated: January 4, 2008

 

 

SCL attempts to mimic four levels of intelligence that evolved through an eternal struggle between predator and prey. This may at first seem difficult to accept since most think of predators out-muscling their prey and prey outrunning their predators; images of cheetahs and gazelles growing faster and faster. But that is not intelligence. Intelligence is the predator’s ability to hide from the prey and the prey’s ability to glide under the radar of the predator. The four levels, from most mundane to that of our human intelligence are as follows:

 

1.    Simple recognition. This is pretty much Boolean logic. This is the “push-button”, “insect and fish” recognition. At the simplest level it means IF X AND Y AND Z THEN Execute”. However, simple recognition goes further as in IF (X AND Y AND Z) OR (A AND B) THEN Execute”. The OR means that a particular action can be triggered by more than one rule.

 

Creatures possessing simple recognition are stupid. Such creatures suffer from false negatives. This means that they fail to recognize situations because their rules are too rigid. For example, we can easily catch fish because we only need to mimic the movement, smell, and shape of a fish’s prey with a hook, line, and bait, and it will fall for it every time … well, maybe not. The important things are that the rules are such that a certain percentage of the members will survive to reproduce. This isn’t too different from a casino winning a certain percentage as long as the rules are strictly adhered to.

 

This is the general state of most software today. Rules are rather hard-coded (for example, as IF-THEN, CASE-WHEN, or IIF statements). However, many inputs used by the rules are soft-coded; for example, configuration files for an application where values can be set independently of the software.

 

In general the variables plugged into a rule are directly measured and factual values. In fact, the key difference between Simple and Robust (#2) recognition is that for the latter, variables plugged into a rule are the result of rules. Simple recognition is like a function or Web Service call these days that accept a fixed set of parameters (even though there may be multiple “signatures” for the call) which are all solid values processed by the rules encapsulated by the function.

 

Simple recognition rules assume a direct hit.  Direct hits are possible either because the rules try to recognize something vague (recognizing a shadow, which is simply a change of light) or the rules are cut and dried (such as calculating tax). However, the problem with direct hits is that in the dynamic world we live in, direct hits are usually not feasible. Therefore a rule will be rather loose in a “better safe than sorry” manner. For example, a fly will react to any movement since it would require too many rules to determine if the movement of a nearby animal is meant to hurt the fly or unrelated to the fly.

 

The reason why insects and fish species thrive with simple recognition is that they reproduce in prodigious numbers. The simple rules by which they live ensure that a certain, albeit very tiny, fraction of the individuals survive to reproduce (again, in prodigious numbers).

 

2.    Robust recognition. This is lower reptile and bird intelligence. Variables plugged into rules can themselves be queries (a simple recognition). Robust recognition is a network of simple recognitions. This is soft-coded logic, the separation of logic and procedure.

 

Robust recognition is different from simple recognition in that the rules are not rigid resulting in direct hits. The main requirement for robust recognition is to recognize something complex or avoid having too many rules (the too many false positives problem).

 

For example, if a rabbit is to recognize a fox stalking it, it would need to do this from an incredibly large number of angles. In order to learn that, it would need to first see the fox from all angles.

 

It would take forever to process all of those rules from each angle. If the requirement for a direct hit is removed, the rabbit can successfully recognize the fox quickly and fairly accurately through a less direct hit.

 

With simple recognition, the fox would need to be an exact shade of red, an exact size, have an exact smell, etc. With simple recognition, the shade of red is determined through a rule that takes into account the level of light and other things.

 

With robust recognition, the “too many false positives” problem is resolved. This is a little different from the fox and the rabbit problem. The rabbit and fox problem is a rabbit needing to recognize something in many different ways. This problem occurs when there are so many learned rules that too many rules fire. This problem would be restated from “Is this a fox?” to “What has ears and a nose?”

 

That is different from the “fuzziness” of simple recognition where a creature recognizes only simple things. A rabbit attempts to recognize a more complex object in a fuzzy manner than to run away from all objects.

 

Software today is beginning to apply such mechanisms resulting in smarter applications.

 

3.    Iterative recognition. Part I of higher animal (higher reptiles and mammals) recognition. The difference between robust and iterative recognition is that iterative recognition will actually take steps to proactively improve the recognition accuracy by iteratively proving it through experiments and feedback. Iterative recognition adds a process that begins with a list of possibilities and culls the list by gathering more data to prove which possibility is the most likely. Each iteration could add new possibilities as well as new evidence is gathered.

 

Vision makes a bigger impact as a sensory role. With vision, comes the ability to camouflage. This camouflage is generally not perfect. If a reptile spots a partial view of its prey, because the match isn’t perfect, the reptile’s recognition rule doesn’t fire and it pass up an opportunity to eat. (How often will it find prey in full view?) Therefore, it must recognize that partial view as a “hypothesis” rather than a direct match and begin to prove the theory through iterations of query and experiment. For example, we see something in the distance that looks like a shady tree to sit under. But something isn’t quite right about it. We walk more closely and it looks even less like a tree. Or we toss a rock at it to see anything moves. We walk closer and see that it’s a bear holding tree branches.

 

So a creature with iterative recognition may be smarter about recognizing something, but it has to also needs to be smarter about knowing what to do about it; which brings up #4.

 

4.    Decoupled Recognition and Action. This is Part II of higher animal recognition; of which humans are in a class of their own. It’s the human’s ability to think symbolically that separates us from all other animals. That is, we’re able to perform experiments in our head before actually committing to a physical action, which is probably not retractable. Something may be recognized accurately (using iterative recognition), but what do we do about it? For example, we do recognize that it’s a bear (from item #3 above). What do we do? Do we run away? Do we fight? Do we pray to our maker and wish the bear bon appétit? Is it really a threat? Maybe the kind bear is offering us shade. The point is that recognition is only half the problem. Deciding what to do is what keeps us from being caught with a fishing hook and bait.

 

Humans, with our self-awareness, are each a species of one. Most creatures aren’t really aware of their mortality. All that matters for most species is that enough individuals survive to produce the next generation. Humans are aware of our mortality and do much to preserve our lives. Like an entire species, each human fills a niche, each carries a unique intelligence, each is capable of profoundly changing the world.

 

Lastly, humans and all mammals still do rely on simple recognition. We still encounter dangers that require a very quick “better safe than sorry” response. These are the knee-jerk reactions we may have to sudden loud noises or shadows appearing around the corner of our eyes.

 

SCL/RDB facilitates the “robust recognition” level of intelligence. Basically, robust recognition means that something, an object or event, can be recognized from many different angles, some angles of which are not explicitly defined. In contrast, my full vision for SCL is to facilitate “decoupled action and recognition” and most software implements “simple recognition”. The former is essentially the recognition of something, but further analysis is required in choosing the proper action. The latter is a “push-button” action; a button is pushed and an action is executed.

 

 

 

Related Articles:

 

·         The Limitations of Simple Recognition

·         Imperfect Information