Loosemore's Collected Writings on SL4 - Part 4

From: Richard Loosemore (rpwl@lightlink.com)
Date: Sat Aug 26 2006 - 20:36:14 MDT

[begin part 4]

* *
* The Complex Systems Critique (Again) *
* *
Ben Goertzel wrote:

> Richard,
> I think you have made a reasonably convincing argument why
> AGI should proceed via allowing a proto-AGI system to
> engage with a world via sensors and actuators, and
> construct its own symbols to represent the world
> around it. I agree that these symbols will generally
> not be simple, and also that sophisticated learning
> mechanisms will be required to learn them.
> What is not clear to me is why the "complexity" of
> these symbols and learning mechanisms necessarily
> has to entail "complexity" in the sense of
> complex systems theory (as opposed to just
> "complexity" in the sense of complicatedness
> and sophistication).

Your question makes me fear that I muddied the waters when I talked
about the complicatedness of symbols. And I was trying so hard, too!

The answer to your question was in the text, but alas it may have gotten
buried. When I talked about the "complicatedness" of the symbols, I was
summarizing something that I then (later on) tried to spell out in more
detail: I was postulating that when we try to get serious amounts of
high-level learning into an AGI (analogy-making and so on), we are
forced to put in precisely the kinds of tangled, reflexive,
self-modifying mechanisms that leads to complexity in the system as a
whole, and in complicatedness in the symbols.

Even without any other arguments, I was claiming, we should be deeply
worried that AGI programmers tend to shy away from trying to build those
very high-level learning mechanisms. Is it fair of me to say this? Do
they really shy away from them? I think they do. Many AGI folks talk
about such stuff as if it is next on the list after they get the basic
mechanisms sorted out - but it might also be that the real reason people
avoid them is that nobody has much idea how to build them *without*
straying into the domain of complex, self-modifying, tangled, recursive
(etc) systems. Let me put the same point, but coming from the other
direction: do you see any research groups throwing themselves full-tilt
into the problem of understanding those high-level learning (aka
concept-building or structure-finding) mechanisms? Oh boy, yes! For just
one example, look at the FARG group at Indiana U
(http://www.cogsci.indiana.edu/index.html). But these folks take the
complex-systems approach. They eat, drink and breathe complexity.

So it is not that the complicatedness of symbols means anything by
itself (I apologize for misleading you there) - a symbol, after all, is
a local mechanism, and the point of a complex system is that the
complexity is in the system as a whole, not in the local units. No, what
I meant was: the symbols have to be complicated precisely because we
need to make them develop by themselves using powerful (tangled,
complex) learning mechanisms. [The complicatedness of the symbols raises
a slightly different issue that I started to discuss, but for clarity I
will leave it aside here and come back to it if you wish].

I submit that most AGI people assume that they are going to be able to
crack the learning problem later, *without* having to resort to tangled
complexity. They believe that they will be able to invent all the
learning mechanisms required in an AGI without having to give those
learning mechanisms the power to trasnform the system as a whole into a
complex system.

I further submit that they believe the format for the symbols that they
are using now (relatively uncomplicated and interpretable, in my
terminology) will not be substantially affected by the later
introduction of those learning mechanisms. When I talked about the
symbols becoming more complicated, I was referring to this assumption,
saying that I believe that the later introduction of proper learning
mechanisms will actually affect the format of the symbols, and that the
change may be so huge that we may discover that the only way to get the
symbols to develop by themselves (supplied only with real world I/O and
no programmer intervention) is to to give them so much freedom to
develop that all the apparatus we put into in the symbols, that we
thought was so important, turns out to be redundant.

So all of this is about observing a process within the AI community.
Specifically, these observations. (a) I see people (over the course of
at least four decades now) concentrating on the mechanisms-of-thought in
non-grounded systems, and postponing the problem of building the kind of
powerful learning mechanisms that could generate the symbols that are
used in those mechanisms-of-thought. (b) I see a few people embracing
the problem of those powerful learning mechanisms, but those people take
a complex systems approach because all the indications are that the kind
of reflexive, self-modifying characteristics needed in such learning
mechanisms will lead to complex systems. Now, why do the latter group go
straight for complex systems? We need to be careful not to trivialise
their reasons for doing so: they don't do it just because it's fun; they
don't do it because they don't know any better; they don't do it because
they are mathematically naive wimps who have no faith in the power of
mathematics to grow until it can describe things that people previously
dismissed as to difficult to describe .... they do it because they have
an extremely broad range of knowledge, have come at the problem from a
number of angles, and have decided that there is a very profound message
coming from all the studies that have been done on different sorts of
complex system. And the message, as far as they are concerned, is that
*if* you are going to build a mechanism that captures what appears to be
an extremely reflexive, self-modifying and tangled ability as the kinds
of learning and concept building that are important to them, *then* you
had jolly well better get used to the idea that the mechanism is going
to be complex, because in the thousands upon thousands of other examples
of systems with that kind of tangledness, we always observe an element
of complexity.

So, from these two observations, I take away this conclusion. The people
who insist that we will be able to build powerful learning mechanisms in
an AGI *without* recourse to complexity, are precisely those people who
have not tried to build such mechanisms. They offer a firm conviction
that they will be able to do so, but they can offer nothing except their
blind faith in the future. [And where they do attempt to build learning
mechanisms, they only try relatively simple kinds of learning (concept
building) and they have never demonstrated that their mechanisms are
powerful enough to ground a broad-based intelligence]. The only people
who have ventured into this domain have accepted the evidence that
complexity is unavoidable, and they give reasons why they think so.

The standard response to this argument (at least from some quarters in
this list), is that I have not given a demonstration why an AGI *cannot*
be built without complexity, or a demonstration of why complexity *must*
be necessary. This is a completely nonsensical demand: a rigorous proof
or demonstration is not possible: that is the whole point of my
argument! If I could give a rigorous mathematical or logical proof why
you cannot build an AGI without complexity, the very rigor of that proof
would invalidate my argument!

I most certainly have given a demonstration: it is an empirical one.
Look at all the examples of learning systems that work; look at the way
the non-complex AGI researchers run away from powerful learning
mechanisms and never demonstrate any convincing reasons to believe their
systems can be grounded; look at all the evidence from natural systems
that are intelligent, but which do not use crystalline, non-complex
thinking and learning mechanisms; look at all the systems which have
large numbers of interacting, self-modifying, adaptive components that
interact with the world (not just intelligent systems, but all the
others) and ask yourself why it is that we cannot find any examples
where someone could start by observing the global behavior of the system
and then reason back to the local mechanisms that must have given rise
to that behavior.

And at the end of all this observing, ask yourself what reason an AGI
researcher has to denigrate the human mind as a lousy design (even
thoughthey don't understand the design!) and say that they can do it
better without introducing complexity, without offering any examples of
working (grounded) systems to back up their claim, and without offering
any mathematical proofs or demonstrations that their approach will one
day work, when they get the learning and grounding mechanisms fully
worked out.

The boot, I submit, is on the other foot. The rest of the community is
asking the non-complex AGI folks [apologies for the awkward term: I am
not sure what to call people who eschew complexity, except perhaps the
Old Guard] why *we* should go along with what looks like their blind
faith in being able to build a fully capable, grounded AGI without
resorting to complexity.


I have concentrated on one aspect of the learning mechanisms (the
expected tangledness, if you like) because this is the most obvious
thing that would lead to complexity. However, this is not the only plank
of the argument. I have brought up some of these other issues elsewhere,
but it might be better for me to organize them more systematically,
rather than throw them into the pot right now.

In closing, let me say that I look very negative when presenting this
argument, even though I actually do have concrete suggestions for what
we should do instead. Some people have jumped to false conclusions about
what I would recommend us doing, if the above were true: the fact is, I
have barely even mentioned what I think we should be doing. Right now,
my goal is to suggest that here we have an issue of truly enormous
importance, and that we should first of all accept that it really is an
issue, then go on to talk about what can be done about it. But I want to
get to first base first and get people to agree that there is an issue.

Richard Loosemore.

[end part 4]

This archive was generated by hypermail 2.1.5 : Wed Jul 17 2013 - 04:00:57 MDT