Re: HHH maps its input to the behavior specified by it --- never reaches its halt state ---natural number mapping

On 8/13/24 8:55 AM, olcott wrote:

On 8/13/2024 2:29 AM, Fred. Zwarts wrote:

Op 12.aug.2024 om 14:42 schreef olcott:

On 8/11/2024 2:54 PM, Fred. Zwarts wrote:

Op 11.aug.2024 om 13:45 schreef olcott:

>
void DDD()
{
   HHH(DDD);
   return;
}
>
None-the-less it is clear that of the above specified infinite
set DDD correctly emulated by each element of that set never
reaches its own "return" instruction halt state.

>
Since no DDD is correctly simulated by HHH, we are talking about the properties of an empty set.
But, indeed, the simulation of DDD by HHH fails to reach the halt state. It aborts one cycle before the simulated HHH would reach its 'return' instruction, after which DDD would reach its halt state.
>

>
My words must be understandable by ordinary C programmers
and computer scientists. The latter tend to conclude that
my work is incorrect as soon as they know the subject matter
before actually seeing what I said.
>

Every C programmer understands that a simulation fails if it does not reach the end of a halting program.

>
Four expert C programmers (two with masters degrees in
computer science) agree that DDD correctly simulated by
HHH does not halt.
>

Many more experts with master degrees tell you that it does halt.
Show evidence instead of authority.

 *Every attempt at rebutting this has been*
(a) Denying verified facts
(b) Strawman-deception of changing what I said and rebutting that
(c) Pure ad hominem insults with zero reasoning

Nope, YOUR CLAIMS have just been
(a) Denying verified facts
(b) Strawman-deception of changing what I said and rebutting that
(c) Pure ad hominem insults with zero reasoning
SAince you have demonstarted that you are nothing but a habitual liar, nothing you say can be taken without actual proof, of which you haven't provided ANY.
SInce it has been shown that you HHH doesn't even meet you own requirement to be a "pure function", until you fix that, nothing you say have anything to base itself on.

 Mike is the only one here that seems to have enough technical
skill to understand the verified facts. Everyone else denies them
entirely on the basis of their own ignorance.
 Overview of proof that the input to HHH(DDD) specifies non-halting behavior
We prove that the simulation is correct.

Nope, If it was "correct" then HHH can not returnm.

Then we prove that this simulation cannot possibly
reach its final halt state / ever stop running without being aborted.
The semantics of the x86 language conclusive proves this is true.

Which means that the only DDD that isn't halting is the one built on the HHH that doesn't abort, and thus isn't a decider.
The semantics of the x86 language says that the correct emulation of the input that HHH does, must also correctly emulate that exact same HHH, and thus if HHH ever returns, DDD will be halting\.

 Thus when we measure the behavior specified by this finite
string by DDD correctly simulated/emulated by HHH it specifies
non-halting behavior.
 

But that only applies *IF* HHH does a complete and correct emulation, as that is the only condition where you r statement holds, and if so, it isn't a decider.
YOu proof fails, because it needs shifiting meani g of words to be true, which isn't allowed.
Sorry, you are just too stupid to understand what you are doing.