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

Op 13.aug.2024 om 15:58 schreef olcott:

On 8/13/2024 8:34 AM, Alan Mackenzie wrote:

olcott <polcott333@gmail.com> 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.

>
Your words are understandable; they're just wrong.
>

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.

>
It's not clear what these "expert programmers" have agreed to.  As Fred
has frequently pointed out, your DDD cannot be correctly simulated by
HHH, so you have an empty set about which anything is true.
>

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

>

*Every attempt at rebutting this has been*

>
There's nothing to rebut.  You just keep coming out with blatant
falsehoods, as pointed out by the other posters, here.
>

(a) Denying verified facts

>
That's a lie.  By "verified facts" you just mean "falsehoods PO would
like to be true".
>

(b) Strawman-deception of changing what I said and rebutting that

>
That's a lie, too.  I've not seen anybody else apart from you doing this.
Indeed you're doing this as a response to Fred's last post.
>

(c) Pure ad hominem insults with zero reasoning

>
That's also false.  The insults follow as a result of your falsehoods and
lies.  They are entirely justified.  You continually insult other posters
by several means, including ignoring what they write.  If you would
actually treat them with respect, the insults against you would cease.
>

Mike is the only one here that seems to have enough technical
skill to understand the verified facts.

>
You mean agree with your falsehoods.  Mike doesn't do this.  You wouldn't
know technical skill if it bit you on the nose.
>

Everyone else denies them entirely on the basis of their own ignorance.

>
You're the ignorant poster here, nobody else.  You've taken a small part
of an undergraduate mathematics or computer science course, something the
typcial student would master in a few hours at most, spent 20 years on
it, and you still don't get it.
>
[ .... ]
>
>

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

>

 void DDD()
{
   HHH(DDD);
   return;
}
 Through something like mathematical induction we can directly
see that DDD correctly emulated by any HHH cannot possibly
reach its "return" instruction final halt state.
 HHH is only required to predict whether or not an unlimited
emulation of DDD would ever halt.
 Thus when computing the behavior that this finite string
specifies DDD never halts.
 _DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
 DDD always has the exact same finite string of machine
code bytes. This requires each HHH to always be at machine
address 000015d2.
 The computation is always reporting whether or not DDD
can possibly reach its c3 "ret" instruction at machine
address [00002183].
 

Since we see that each of the simulations fails to reach the c3 ret instruction, although it is specified that HHH halts after N cycles, this proves that each of these simulations is incorrect. Mathematical induction then proves that all of them are incorrect.
You keep dreaming of the HHH that does not abort and does not halt, but most of these HHH abort and halt. Dreams are no substitute for facts.
The unlimited simulation halts, as is proven when HHH is simulated by HHH1.