Re: Analysis of Richard Damon’s Responses to Flibble

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.
The fact that H got into the unbounded recursion to figure its answer, is its problem, not a problem with the input.
What it means is that perhaps UTMs can't exist in your system, as there are some input that can't be simulated, but can be run, which just shows that such a system isn't Turing Complete.