Re: Implausibility continued (in C)

On Sun, 23 Sep 2007 03:50:42 -0700, someone3 wrote:

On 23 Sep, 10:46, Garamond Lethe <cartographi...@xxxxxxxxx> wrote:
On Sat, 22 Sep 2007 16:08:07 -0700, someone3 wrote:
On 22 Sep, 23:23, Garamond Lethe <cartographi...@xxxxxxxxx> wrote:
On Sat, 22 Sep 2007 14:31:54 -0700, someone3 wrote:
On 21 Sep, 10:35, Garamond Lethe <cartographi...@xxxxxxxxx> wrote:
On Fri, 21 Sep 2007 02:20:41 -0700, someone3 wrote:
On 21 Sep, 04:59, Garamond Lethe <cartographi...@xxxxxxxxx> wrote:
In this episode, I give Glenn a magic box which doesn't turn out to be
quite as useful as he'd hoped, and I get to cut and paste several large
numbers.....

On Thu, 20 Sep 2007 08:35:56 -0700, someone3 wrote:

<snip>

The issue here is that I am talking about predicting what the computer
will do a certain period of time ahead.

Precisely.

You aren't, you are talking
about whether there is a known answer to a question about an
algorithm.

What did you think the computer was executing if not mathematical
algorithms? (I've got an old Sparcstation that *seems* to run on mashed
potatoes, but I haven't made a complete investigation.)

It's all math, Glenn. Every machine instruction is performing a
well-defined mathematical operation. It's perfectly reasonable to think
about programs mathematically -- in fact, it's much more reasonable to
think about programs this way than, say, molecules.

We are predicting what the computer will do when we step though the
algorithm it will be running. We haven't run it on the computer, we
are just predicting what the computer will do.

By the way, do you think Brownian motion is explainable?

Are you implementing your neural network using Brownian motion? No?
So it's not relevant. As you were so kind to remind me,

The issue here is that I am talking about predicting what the computer
will do a certain period of time ahead.

I'm in an unusually good mood today, so I'm going to give you a present:
a slightly used magical box M that will calculate the exact state of a
machine n steps in the future. It's not quite instantaneous, it has a
few scratches, and it will only work for machines considered in this
thread, but I think you'll enjoy it.

Even using this magic box, there still exist deterministic programs that
are not predictable. Specifically, we don't have a general way of
determining whether or not a program will halt, and this will obviously
have an affect on several other program characteristics. With your new
(to you) box, you might think that all that's necessary is plugging in a
sufficiently large number and seeing if the program is in the halt state.
It's very intuitive to think that, at some finite point, all programs that
are going to stop have stopped, and all the rest of the programs that are
still running must be in an infinite loop.

So what should that limit be? Something big, obviously. A billion? A
trillion? How about the number of atoms in the universe? That's
(roughly) 10^80. But I'm a sneaky ***, remember? How about you make
your guess 10^800, just to be on the safe side. That's 800 zeros, or 10
lines of 80 zeros each.

How steps does the follow program execute?

A: B1R F0L
B: C0R D0R
C: D1L E1R
D: E0L D0L
E: A0R C1R
F: A1L Z1R

You plug it in to your box and get out the answer: >10^800. Is it in an
infinite loop?

Nope.

It runs for 3.0*10^1730 steps and halts.

This is a very pretty number to look at.

steps = 30023277165235628289551030183413401851477543372467\
52500373381801735214240760383265881912082978202876\
69898401786071345848280422383492822716051848585583\
66815379725143861856173020941548768557007853865875\
73048574872220400307698440450988713670876150791383\
11034353164641077919209890837164477363289374225531\
95512602325117225903457015508730368365463087415599\
08225161299384258306913786072736707081901605255340\
77040039226593073997923170154775358629850421712513\
37852708622311268067797375179003293757852001766679\
22468399088559203629337677447608701284468834554778\
06316491601855784426860769027944542798006152693167\
45282133668991746088610648657418901540119403485757\
77182530655416326563343142423255924867001185067165\
81303423271748965426160409797173073716688827281435\
90463944560592817525404832110930600247465896810879\
33819123818123362279928399308330859334788531765747\
02776062858289156568392295963586263654139383856764\
72805139496555440968845657812274329631996080836809\
45364210391495849467580065091609857013289970263017\
08760235500239598119410592142621669614552827244429\
21741646549436389169711396531689266061170929004858\
06775661787157523545940490167192780698328665223329\
23541370293059667996001319376698551683848851474625\
15209456711061545198683989449088568708224497877455\
14532043585886615939797639351028965232958039400236\
73203101744986550732496850436999753711343067328676\
15814626929272337566201561282692410545484965841096\
15740312114406110889753498991567148886819523660180\
86246687712098553077054825367434062671756760070388\
92211743493263344477313878371402373589871279027828\
83771982603800651050757929252394534506229992082975\
79584893448886278127629044163292251815410053522246\
08455276151338393462312908326694937738095046664312\
1689746511996847681275076313206

(Cut 'n' paste courtesy ofhttp://www.drb.insel.de/~heiner/BB)

That's 6 states: 12 reads, 12 writes, 12 moves, and 12 changes of state.

Well, what if instead of using a constant, you used a function? For a
program with n states, what if you calculate your upper limit f() to be:

f(n) = n(^n(^n(^n(^n(^n(^n(^n(^n))))))))

Anything with more steps than this has to be in an infinite loop. Looks
good, right?

What Rado proved is that Sigma(n) [the number of 1s] and S(n) [the number
of steps] are *noncomputable functions*. That means for *any* f(n), there
exists some n where S(n) is going to be much, much bigger than f(n).

The two points I wish to make here are that very simple programs can
exhibit very complex behavior, and that very simple programs can exhibit
non-predictable emergent behavior (in this case, halting or infinite
looping).

With those two points firmly in place, I'd now like to discuss a much more
complex program: your neural network.

Are you willing to do so?

No, because we still haven't cleared this up.

You are avoiding answering questions such as whether Brownian motion
is explainable. It is relevant, as it can't be predicted, yet most
people, you maybe being an exception, would concede that we can
explain Brownian motion. Using your line of reasoning you would be
saying that we can't explain Brownian motion, would you agree?

Of course not. Why do you think predictions and explanations are binary?
We have excellent *probabilistic* models of Brownian motion, and to that
extent we can make predictions about statistically significant behavior.
We *can't* accurately predict exact locations of individual particles far
in the future. Thus, our ability to explain the system is incomplete.

Have you taken a physics class? This is really basic stuff.

I can explain quite a bit about the examples I've given you. I can't
predict (in the general case) whether or not they will halt. Thus the
explanation is incomplete and the behavior is not (fully) predictable.

If you were stepping through the algorithm on a piece of paper, and
writing down each iteration, and someone were to ask you why you were
writing down what you were, are you saying that you couldn't explain
it to them?

Of course not. I can explain the mechanism perfectly. I can forecast a
few moves ahead. I *can't* predict if it will halt. Thus it's
deterministic and not-completely-predictable.

I had said:
------------
The issue here is that I am talking about predicting what the computer
will do a certain period of time ahead.
------------

To which you replied:
------------
Precisely.
------------

So which amount of time ahead, are you claiming the behaviour of the
computer couldn't be predicted for?

You have a magic box now, remember? You can perfectly predict any finite
number of steps ahead. That doesn't allow you to predict if the machine
will halt.

I seem to remember writing a post about this. Ah, yes, you quoted it. In
full.

Would you mind reading it?

You didn't answer which amount of time ahead, are you claiming the
behaviour of the computer couldn't be predicted for?

We're not going to agree on a definition of "prediction". Maybe "formula"
would have been better. Anyway, it's not important to the point I'm
trying to make, and so I'm allowing you to predict a finite number of
steps into the future with perfect accuracy. This doesn't solve the
Halting Problem or the Busy Beaver problem.

You simply seem to be pointing out that if the only method of
prediction is stepping through what would happen, that you can't
predict potentially an infinite amount of steps ahead.

The problem is predicting whether or not a machine will halt.

You seem to allow that explanations of the difficulty of predicting
certain behaviour (such as Brownian motion) are acceptable, would you
allow an explanation that as you can only predict a finite amount of
steps ahead for the computer, that if certain behaviour would never
happen (halting for example) that as you can only predict a finite
time period ahead, you would never get the prediction of it halting
(as it won't happen), yet that isn't a proof that it won't, as it
could always be said to halt the next step. It isn't an issue of
inability to predict the behaviour a finite amount of steps in the
future (not statistically, but with 100% accuracy), it is a problem of
not having a mathematical proof that the prediction of it halting
wouldn't be found at n + x (n being the amount of iterations in the
future predicted, x being the number of further iterations that would
have been required to have predicted the halt state).

The problem is algorithmically distinguishing between a machine that's
running a really long time (but will eventually halt) and one that won't
ever halt. There is no general solution.

Here's the problem.

http://en.wikipedia.org/wiki/Halting_problem

Regarding what we mean by a prediction, I would have thought that a
prediction is saying what will happen before it happens. What were you
thinking a prediction was?

Exactly that, of course. In this case, predicting the behavior of a
program without executing it first, esp. without executing it on another
computer, including computers made of pencils and paper. You don't
understand this. I'm fine with that.

In this case we are talking about
predicting the behaviour of the computer running the program you
supplied earlier.

I understand the problem regarding not having a mathematical proof
that the prediction of it halting
wouldn't be found at n + x (n being the amount of iterations in the
future predicted, x being the number of further iterations that would
have been required to have predicted the halt state).

You don't understand this either. It's not n+x, it's n+f(x), where f(x)
is not computable. I'm ok with you not understanding this, either.

I outlined it
above.

We are interested in if we can explain why the computer running the
program you supplied exhibits the behaviour it exhibits.

And in the general case, we can't.

You suggested
that an explanation isn't an explanation if it can't predict. So a
"magic box" isn't useful in our investigation, as that wouldn't be
predicting based on an understanding, and thus not demonstrating that
the explanation of what is happening was indeed an explanation.

Again you didn't answer which amount of time ahead are you claiming
the behaviour of the computer couldn't be predicted for (it's like you
were trying to avoid answering it),

Any finite amount. Third time I've answered that, I think.

so I'll try another question for
you (as you have repeatedly avoided that one). Do you accept that it
can be predicted how the computer running the program will behave for
ten minutes, if it was doing 1 iteration per second, based on the
understanding of what is going on, and that it could also be predicted
for twenty minutes, and a day (the same understanding/explanation of
what is going on allows predictions for different finite time
periods)?

Who cares? My point was that we can't predict emergent behavior in the
general case. I think we agree. So I'm happy to grant you the point that
you can predict for some finite number of steps in the future. That's why
I gave you your magic box.

This glosses over the difficulties in making such predictions, but frankly
the nuances of that argument are going to be lost on you. So, you get a
freebie. You can, with your box, predict any number of steps you like (as
long as it's computable).

Now, about this fitness function. Given two robots, how do you
distinguish which is closer to your ideal robot? "Acting consciously" is
probably what you mean, but could you reduce that to mathematical terms?
(This is probably going to require that you spell out what you mean by
"acting consciously".)

As I said, we don't need the magic box to predict a finite amount of
steps into the future what the computer is going to do. We can do it,
because we understand how it works, and the explanation as you concede
does allow us to predict a finite amount of time into the future (like
they do with the weather, but with 100% accuracy) how the computer
will behave.

Can you predict if the program is in an infinite loop?

No, you can't.

Deterministic, non-predictable programs exist. This is a good thing to
keep in mind as we discuss your neural network.

What's the fitness function?

So we're just left with your denial that physicalists
don't know why physical activity would consciously experience which we
are covering in the other post, and then both your objections will
have been shown to be unfounded.

.

Loading