I did not take credit for someone else's work. I clearly credited the original author for their portion and linked to their original work. and the posted portion shows exactly what I added.

Yes that is why the title of the original question was: Can D simulated by H terminate normally? I updated my post (above) to show this. So far there has not been one answer. What you said was close to an answer.

Not one person has acknowledged that D correctly simulated by H cannot possibly terminate normally. Many people have been terribly rude and very unprofessional. Even now you did not directly answer the question.

Although people have very consistently treated me very badly what I have been saying is clearly correct software engineering. Can D simulated by H terminate normally? The x86utm operating system based on an open source x86 emulator. This system enables one C function to execute another C function in debug step mode. When H simulates D it creates a separate process context for D with its own memory, stack and virtual registers. H is able to simulate D simulating itself, thus the only limit to recursive simulations is RAM.

01 int D(int (*x)())  
02 {  
03 int Halt_Status = H(x, x);  
04 if (Halt_Status)  
05 HERE: goto HERE;  
06 return Halt_Status;  
07 }  
08  
09 void main()  
10 {  
11 H(D,D);  
12 }

Execution Trace main() calls H(D,D) that simulates D(D) at line 11 keeps repeating: simulated D(D) calls simulated H(D,D) that simulates D(D) at line 03 ... Is this clear enough to see that D correctly simulated by H can never terminate normally? (because D remains stuck in recursive simulation) I never mentioned this next part in any of my questions because it extends beyond the scope of software engineering.

Quote:

For any program H that might determine whether programs halt, a "pathological" program D, called with some input, can pass its own source and its input to H and then specifically do the opposite of what H predicts D will do. No H can exist that handles this case. Wikipedia: Halting Problem

ADDENDUM By showing the above at the software engineering level with fully operational code there cannot be any gaps in reasoning that occur when examining these things at the Turing Machine level. Once these things are fully understood at the software engineering level then they can be applied to the Peter Linz (Turing machine based) Halting Problem proof on pages 1-2 of this paper: Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs It is easy to see that these two examples are isomorphic once the software engineering of the above example is fully understood.

I am revoking my license to this

I took the time to point-by-point show the errors of a video of a working perpetual motion machine that was being promoted on Facebook. This took me less than five minutes. When anyone tries to do that with my claim they run into the brick wall of this tautology: When simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running unless aborted then H is necessarily correct to abort its simulation and reject this input as non-halting.

The issue is not that people don't care. It is that they consider the entirely unsupported opinion of their reference group to carry infinitely more weight than the actual verified facts.

It has brought me to the harsh realization that humanity really is in the post truth era.

The objective facts prove that I am correct thus superseding all opinions to the contrary. I really hope that you don't feel this same way about climate change.

In other words you too are not going to bother to take five minutes and verify that D correctly simulated by H cannot possibly terminate normally because it remains stuck in recursive simulation.

If everyone here agreed that page three of this paper is correct and they sincerely meant this, then I would know that I have finally made my point clear enough and I would submit page three to letters to the editor of CACM. Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs I might have to come up with a much less controversial title such as: Simple Termination analysis between executing C functions.

I generally get the same response that I am getting here. Everyone is so sure that I must be wrong that they don't bother to look at a single word that I have said and simply vote me down until the post is deleted. Any BSCS graduate taking five minutes to examine my code can see that D correctly simulated by H cannot possibly terminate normally because it remains stuck in recursive simulation. That by itself should be enough to pique their interest in looking at the additional details. Because my writing style is not even close the the writing style of a published PhD researcher what I say is almost always rejected out-of-hand without review of the substance of what I have said.

Two people each with masters degrees in computer science have confirmed that D correctly simulated by H cannot possible terminate normally. MIT Professor Michael Sipser1 agreed that the following verbatim paragraph is correct: If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running unless aborted then H can abort its simulation of D and correctly report that D specifies a non-halting sequence of configurations. He has also agreed that I can quote him on this. He has only agreed to the above word-for-word paragraph. He has not agreed with anything else. 1 author of the best selling book on the theory of computation Introduction to the Theory of Computation 3rd Edition

He has already made up his mind and closed it. I really shouldn't even need that quote. Anyone with at least a BSCS can verify that it is necessarily true. The technical term for a statement that is necessarily true is tautology.

This is the 12th article that I have written up in the last two years: Simulating (partial) Halt Deciders Defeat the Halting Problem Proofs

"You are using an example which has a very specific context - the Turing Machine." Not at all. The code that I wrote is very clearly written in C. I am only asking a straight forward software engineering question about a pair of C functions. Asking about the computer science implied by my question is clearly beyond the scope of this site so I am not asking about that.

I spoke very extensively with Moshe Y. Vardi the former editor in chief of the CACM about two dozen emails altogether. Back then I could only prove my point though an x86 machine language execution trace. He did not know the x86 language at all so I made zero progress. The only huge success that I had was with: MIT Professor Michael Sipser has agreed that the following verbatim paragraph is correct: If simulating halt decider H correctly simulates its input D until H correctly determines that its simulated D would never stop running unless aborted then H can abort its simulation of D and correctly report that D specifies a non-halting sequence of configurations. He also agreed that I can quote him on this. It is only the above paragraph that he has agreed to.

I am aware that there are journals that accept any material if you pay them enough. My aim is Communications of the ACM, where Edgar Dijkstra got his start. Edgar Dijkstra: Go To Statement Considered Harmful

And examining the complete github code of H posted on a link in these messages we can see that H itself correctly determines that D correctly simulated by H cannot possibly terminate normally. H simply recognizes a dynamic behavior pattern having the same form as infinite recursion. For any program H that might determine whether programs halt, a "pathological" program D, called with some input, can pass its own source and its input to H and then specifically do the opposite of what H predicts D will do. No H can exist that handles this case. Wikipedia: Halting Problem Finally we can also see (From the above Wikipedia quote) that H and D have the exact halting problem relationship to each other. Thus it is clear from a software engineering perspective that H does correctly determine the halt status of the halting problem's "impossible" input. If I was actually wrong someone could point out a mistake.

The software engineering easily proves that D correctly simulated by H cannot possibly ever terminate normally to everyone having at least a bachelor's degree in computer science. Two people each with a masters degree in computer science have agreed that D correctly simulated by H cannot possibly terminate normally.