My definition of "intelligence"
D. S. Blank

As we have seen from Braitenberg's Vehicles, there is a disconnect
between how a machine actually works, and how we might guess how it
works by simply watching its behavior.

Usually, we attribute emotions, desires, intentions to the machine
when we could more easily describe the behavior in simple mechanical
terms.

In any event, we can either try to define intelligence based on one of
those two methods:

   1. define intelligence based on how something works

   2. define intelligence based on our perception of how it works

Option #2 seems ridiculus! Why would one define something based on our
perceptions of it rather than on the actual thing. Ok, then, let's
examine the only serious option, #1.

In order to judge something's intelligence, we merely need to know how
it works. For example, we could look at the wiring, or study a program
that controls a robot or computer, and then determine if it is
intelligent. Some problems pop up:

1. What if we can't get inside the machine (e.g., it might be in
   someone's skullcap)?

If we need to have a measure of intelligence, but can't get inside,
this method leaves us empty.

2. What if we can't really "know" how it works? What if it is really,
   really complicated with wires running everywhere, and a huge number
   of interactions in real time?

We know that just having wires everywhere doesn't make a system
intelligent, otherwise the lab might be teaming with IQ. We might try
to make abstractions about how it works, but there is nothing that
says that intelligence will be organized in a nice coherent manner.

3. Even if we know exactly how it works, how do we judge a system's
   intelligence? What are we measuring?

To my mind, each of these problems lead right back to where Turing
started the whole debate: using the Turing Test to judge the behavior
of a system. But that is exactly option #2!

Let's see if we can scientifically make a defintion for intelligence
using the Turing Test as a base.

First, a simple version:

intelligence - a measure of the sophistication of a system's behavior

But then, how do we define "sophisticated behavior"? Isn't that just
intelligence in different terms? How could we have a specific method
of measure this sophistication?

What if we used model building as the measure of sophistication? That
would give us:

intelligence - the measure of the complexity of a model that
sufficiently explains a system's behavior

Of course, that leaves "complexity" undefined, but it seems like we're
getting somewhere. I'm thinking that models that involve notions like
"memory", "variable", "plan", "analogy", "representation", etc. would
have a high measure. Models that use "lookup table", "randomness",
"stimulus-response", "search tree", etc. might have a lower measure.

But, this all depends on the context. For example, if the lookup table
were large enough, it might be very sophisticated. So, we'll add the
idea of context to our definition:

intelligence - the measure of the complexity of a model that
sufficiently explains a system's behavior in a given context

You could have a variation so you wouldn't actually need to build a
complete model:

intelligence - the measure of the complexity of the concepts one must
invoke in order to sufficiently explain the behavior of a system in a
given context.

One can explain one's own behavior using this method, and thus have a
perception of one's own intelligence.

Note that this definition is not based on cause-effect but a
perception of behavior. Intelligence is therefore a perception; it can
change with the development of the observer.

A model might involve "emergence" which is simple to explain in one
(microscopic) context, but would actually be a complex model in the
higher (macroscopic) context. 

This allows for the possiblility that a machine might not have a model
any more abstract than itself. That is, the actual machine can't be
abstracted, and any model will be as complex as the machine.

But that's ok, because we don't need to try to make abstractions.

Related idea: a system can't "understand" itself (i.e., build an
abstract model) until it gets sufficiently complex. As soon as it gets
sufficiently complex, it is unable to "understand" itself (an abstract
model is not powerful enough).

In what way is this argument anti-scientific? Is there a way around
these issues to save option #1?