Re: D correctly simulated by pure function H cannot possibly reach its, own line 06 ---

On 5/26/24 1:26 PM, olcott wrote:

On 5/26/2024 12:16 PM, Richard Damon wrote:

On 5/26/24 1:01 PM, olcott wrote:

On 5/26/2024 11:31 AM, Richard Damon wrote:

On 5/26/24 10:13 AM, olcott wrote:

On 5/26/2024 6:43 AM, Richard Damon wrote:
>
typedef int (*ptr)();  // ptr is pointer to int function in C
00       int H(ptr p, ptr i);
01       int D(ptr p)
02       {
03         int Halt_Status = H(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         H(D,D);
12         return 0;
13       }
>
>

Because, as I have said, the answer and reasoning changes depending on what you acknowledged are the implications of your stipulations. For instance, if your actual understanding of being a "Pure Function" is that the program is the equivalent of a Turing Machine, then we need to add a strictness to the definition that isn't normally used for just "Pure Functions", like accessing value of registers like the program counter or stack pointer might not be allowed in some cases. (which breaks you H).
>

>
Since we can see (and you already agreed) that D correctly simulated
by pure simulator H remains stuck in infinite recursive simulation then
we also know that D never reaches its own line 06 and halts in less
than an infinite number of correctly simulated steps.

>
But it depends on what H actually does, which you refuse to agree to.
>

>
When I specify that D is correctly simulated by pure function H, that
means that H is a pure simulator that stops simulating D after some
finite number of correctly simulated steps. There is absolutely nothing
else that needs to be known about H besides this.
>

>
And, do you accept that this exact description means that H is NOT the computational equivalent of a Turing Machine, and that this simulation doesn't prove that its input is not a non-halting program?
>

 In other words you are saying that it is 100% totally impossible to
adapt an actual UTM so that it stops simulating after a finite number of
steps.

Yep, at least and have it still be a UTM.
IMPOSSIBLE BY DEFINITION.
That is like talking about a circle that is a square.
You just proved why I am requiring you to accept the implications since you clearly don't know what some of the words you use mean.

 When we see that D correctly simulated by pure simulator H would remain
stuck in recursive simulation then we also know that D never reaches its
own line 06 and halts in less than an infinite number of correctly
simulated steps.

Nope, not if H has aborted its simulation.
You might be describing the behavior of one particular input D given to one particular analyzer H that doesn't ever stop its simulation, but that isn't the H that you are actually talking about, just the one that you are trying to LIE about being the "same".

 This means that D correctly simulated by pure function H also never
reaches it own line 06 and halts.

Nope, not if H has aborted its simulation. If H aborts its simulation and returns 0, the D will actually reach its own line 6 and halt. That IS the behavior specified by your D.
H's simulation won't see that, but that is why H got the wrong answer.
So, you need to be clear what you words mean, which you aren't.

 

Failure to acknowledge this means that you don't understand the meaning of the terms you used, and that you accept the implications.

 I am not the one saying that it is 100% impossible to adapt an ordinary
UTM so that it stops simulating after a finite number of steps.
 

Which is why you are wrong.
That is like talking about the 4 sides of a circle (because you think a square can be a circle).
Yes, you can take the design of a UTM, and change it so that it is no longer a UTM, but a partial simulator that halts after a finite number of steps. It just isn't a UTM any more.
Like talking an Electric car and removing that battery and electric motor and "improving" it with a gas engine. You may still have a car, but it is no longer an "Electric Vehicle".