Re: Analysis of Richard Damon’s Responses to Flibble

On 5/19/25 12:49 PM, Mr Flibble wrote:

On Sun, 18 May 2025 18:59:37 -0400, Richard Damon wrote:
 

On 5/18/25 5:56 PM, Mr Flibble wrote:

On Sun, 18 May 2025 17:29:47 -0400, Richard Damon wrote:
>

On 5/18/25 4:30 PM, Mr Flibble wrote:

On Sun, 18 May 2025 16:18:04 -0400, Richard Damon wrote:
>

On 5/18/25 4:09 PM, Mr Flibble wrote:

On Sun, 18 May 2025 16:03:13 -0400, Richard Damon wrote:
>

On 5/18/25 3:58 PM, Mr Flibble wrote:

On Sun, 18 May 2025 15:49:33 -0400, Richard Damon wrote:
>

On 5/18/25 3:45 PM, Mr Flibble wrote:

On Sun, 18 May 2025 15:19:38 -0400, Richard Damon wrote:
>

On 5/18/25 1:07 PM, Mr Flibble wrote:

>

4. Stack Overflow as a Semantic Signal
--------------------------------------
Damon argues that stack overflow represents a failed
computation:

"...it just got the wrong answer."

>
Flibble’s view is different:
- A stack overflow (or crash) isn’t failure.

>
Sure it is. A program that fails to complete and give the
correct answer has just failed to give an answer.
>
If you want to define "stack overflow" as an "I don't know"
result,
fine, but first you have to define that this is a "valid"
result.

>
No it isn't. Why? Because the stack overflow a property of the
simulation environment (the fact that the SHD has finite
resources)
and NOT a property of the program, P, being analysed per se.  P
is NOT halting, it is the SHD that is halting due to the
detection of infinite recursion on the part of P.  It is
perfectly valid for the SHD to treat this as NON- HALTING as
far as P is concerned.
>
/Flibble

>
No, it is a property of the decider. If your "environment" is
inadiquite, it just shows you aren't using a proper environment.

>
The SHD and the simulation environment are on in the same.

>
And thus a failure of the environment is a failure of the SHD.

>
Not at all, the SHD can abort the simulation if it would result in
stack overflow due to infinite recursion and then return a result
of NON-HALTING.
>
/Flibble

>
Yes, *IF* it can show that the simulation WOULD be infinite for that
exact input.
>
Remember, to simulate it, it must be a complete program, that
includes all its defined code.
>
Thus the "pathological" program, since it is built on a specific
decider, has fixed behavior, as does that specific decider.
>
SO, if the SHD aborts and returns an answer, the the correct
simulation of the "pathological" program will have its decider do
exactly the same thing.

>
How the SHD arrives at a halting result is an implementation detail
of the SHD itself: it can do whatever it wants as far as simulation
is concerned.
>
/Flibble

>
Right, but it is only correct if the answer is correct.
>
And nothing about that say anything about getting a stack overflow
violation.
>
By the basic rules of Compuations, all "answers" must be passed to any
machine that embeds that program, as an out of stack error, if it keep
the embedding program from continuing, isn't an answer and thus a
failure of the decider.
>
In fact, any system that can actually fail with an out of stack error,
and that is considered to be the result, just fails to be Turing
Complete. We can say the problem is too complicated for that system,
and look at what happens with a bigger system, and if it will even
fail with an unboundedly big system, the operation must be
non-halting, and thus just fail to be a decider.
>
Thus, the only possible "answer" that an out of stack error can be
would be the non-answer.

>
No, if infinite recursion is detected then all the SHD needs to do is
return a result of NON-HALTING.
>
/Flibble

>
Right, return to whoever calls it. So, if the system crashes, it fails.
>
If your system catches this out of stack, and winds back to the original
and it returns you are ok, except that if D calls H(D) and H(D) runs out
of stack and rewinds and returns non-halting to D, then D will halt,
making it wrong.

 You are making assertions based on no knowledge of implementation details
of the SHD.  Foolish.
 /Flibble

I speak out of definition of computations.
Note, I did use *IF* to specify a couple of the options, you need to define what your thoughts are about what it actually does.
DOES your SHD catch the error, or does it just fail and crash the machine. BY DEFINITION, crashing the machine is not answering, and makes your systmm less than Turing Complete, and the problme isn't really interesting in less than Turing Complete Systems, as it is Fully Solvable in so many of them.