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

[olcott]

[...]

However, my point was that the common excuse of "I hate this crime so
much I lashed out" is not a valid excuse.

[...]
And you could have made that point without accompanying it by a long
article about various kinds of child abuse in a newsgroup that's
supposed to be about C.
You didn't have to let yourself be trolled.

I don't consider James' post to be trolling.  But of course that in
itself does not mean it is appropriate to reply here.  However, I
replied to that post in the group (rather than email) because it seemed
to me that a point I had made previously needed clarification.
As has been pointed out by others, topicality in this thread was doomed
from the first post.  I'd be happier if Olcott had never cross-posted
here, but we can't change that.

*Someone could simply answer the question instead of*
*spending countless messages on dodging the question*

For every H/D pair matching the following template where
H is a pure function:

Does any D correctly simulated by H reach its own line 06 and
halt or does the fact that D remains stuck in recursive simulation
prevent that?

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 }

It is trivial to see that for every H/D pair of the infinite
set of H/D pairs that match the above template that

D correctly simulated by H cannot possibly reach its own final
state at line 06 and halt because D correctly simulated by
H remains stuck in recursive simulation.

This provides the basis for simulating termination analyzer H to
correctly determine that the halting problem's counter-example
input D cannot possibly halt.

[olcott]

<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.

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

Yes, if H never terminates then neither does D.

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

When we hypothesize that H is a pure simulator we see that D correctly
simulated by pure simulator H remains stuck in recursive simulation thus
never reaches its own simulated final state at its line 06 and halts. In
this case H does not halt, thus is neither a pure function nor a
decider.

From this we correctly conclude that D correctly simulated by pure
function H never reaches its simulated final state at its own line 06
and halts in Less than an infinite (AKA finite) number of simulated
steps. *Here is a concrete example of that*

https://en.wikipedia.org/wiki/Googolplex
When pure function H correctly simulates a Googolplex ^ Googolplex
number of steps of D, then D never reaches its simulated final state
at its own line 06 and halts. Pure function H halts after this finite
number of steps of correct simulation.

In other words when the *INPUT* to H(D,D) is correctly simulated by
either pure simulator H or pure function H this correctly simulated
*INPUT* never halts no matter what, thus the INPUT to H(D,D) is
definitely non halting.

*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.