Re: Every D(D) simulated by H presents non-halting behavior to H ###

On 5/30/2024 5:04 AM, Fred. Zwarts wrote:

Op 29.mei.2024 om 15:17 schreef olcott:

On 5/29/2024 4:08 AM, Mikko wrote:

On 2024-05-28 14:37:15 +0000, olcott said:
>

On 5/28/2024 2:17 AM, Mikko wrote:

On 2024-05-27 13:52:09 +0000, olcott said:
>

On 5/27/2024 3:11 AM, Mikko wrote:

On 2024-05-26 16:50:21 +0000, olcott said:
>

>
<snip>
So that: *Usenet Article Lookup*
http://al.howardknight.net/
can see the whole message now that
*the Thai spammer killed Google Groups*
>
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       }
>

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.

>
Which means that H never terminates. You said that by your definition
a function that never terminates is not a pure function. Therefore
H, if it exists, is not a pure function, and the phrase "pure function
H" does not denote.

>
*I should have said that more clearly*
*That is why I need reviewers*

>
What is said here has little significance. You should ask reviewer's
comments about your working draft that you maintain in GitHub or some
other web site. And you should update that draft when a reviewer finds
some something wrong or unclear.
>

*This is STEP ONE of my four step proof*
STEP TWO applies these same ideas to the Peter Linz HP proof.
STEP THREE shows how the Linz Ĥ.H sees the behavior of its recursive
      simulations.
STEP FOUR shows why the behavior of the INPUT is the correct basis.

>
When discussing individual steps of a proof draft you shold start
at the last step.

>
I have been at this for twenty years.
Ben Bacarisse has spoken with me for 15 of those years.
>
What I found out is that exactly one point of one step
must be pursued until complete closure of that one point
of that one step.

>
How long do you think it takes to cover them all, starting
from the first?
>
How long do you think it would take, starting from the last?
>

>
The first point was closed in less than one hour with each of
four people that were not playing head games.
>
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       }
>
The above template refers to an infinite set of H/D pairs where D is
correctly simulated by either pure simulator H or pure function H.  This
was done because many reviewers used the shell game ploy to endlessly
switch which H/D pair was being referred to.
>
H correctly simulates 1 to ∞ steps of D with either pure function H or
pure simulator H. In none of these cases does the correctly simulated D
ever reach its own simulated final state and halt.
>
Correct Simulation Defined
    This is provided because many reviewers had a different notion of
    correct simulation that diverges from this notion.
>
    A simulator is an x86 emulator that correctly emulates 1 to N of the
    x86 instructions of D in the order specified by the x86 instructions
    of D. This may include M recursive emulations of H emulating itself
    emulating D.
>
When we see that D correctly simulated by pure simulator H would remain
stuck in infinite recursive simulation then we also know that less than
an infinite number of steps is not enough steps for D correctly
simulated by pure function H to reach its own simulated final state at
line 06 and halt.
>

 The stimulation of D does not reach line 06, because the simulation of H does not reach its final state. This means that line 04, 05 and 06 are irrelevant for the claim. What it shows is that D is a parameter duplicator, so that H simulates itself and it shows that H has non-halting behaviour. So, this H is not in agreements of the requirement that it should halt.

H is determining whether or not D correctly simulated by H can
possibly reach its own simulated final state and halt. The
correct answer is no.

 If the simulated H would halt (as is required) then the simulation of D would continue with line 04.

This is incorrect. Only the directly executed outermost H must halt.
Everything else is merely data to this directly executed H.

 That it does not do that, is because H does not return, although it was required to halt.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer