Re: Simulating termination analyzers by dummies --- test of dishonesty

On 6/19/2024 3:48 AM, joes wrote:

Am Tue, 18 Jun 2024 16:29:45 -0500 schrieb olcott:

On 6/18/2024 3:37 PM, joes wrote:

Am Tue, 18 Jun 2024 13:16:42 -0500 schrieb olcott:

On 6/18/2024 12:57 PM, joes wrote:

Am Tue, 18 Jun 2024 12:25:44 -0500 schrieb olcott:

On 6/18/2024 12:06 PM, joes wrote:
void DDD()
{
      H0(DDD);
}
DDD correctly simulated by any H0 cannot possibly halt.

DDD halts iff H0 halts.

So H0 returns "doesn't halt" to DDD, which then stops running, so H0
should have returned "halts".

No counterargument?

Apparently not.
 

Some TM's loop and thus never stop running, this is classical
non-halting behavior. UTM's simulate Turing machine descriptions.
This is the same thing as an interpreter interpreting the
source-code of a program.

Some TMs do not loop and do not halt.

Different people define these terms differently and that gets stuck in
the infinite loop of the meaning of words.

"Looping" means returning to the same combined state of TM+tape.
Halting means arriving at an internal state marked final (no
successors).

Do you agree?
 

A UTM can be adapted so that it only simulates a fixed number of
iterations of an input that loops. When this UTM stops simulating
this Turing machine description we cannot correctly say that this
looping input halted.

Yes. We also cannot say that that input was simulated correctly.

Yes everyone does that thinking that their unsupported proclamation
proves itself until I ask them:
Exactly which step was simulated incorrectly?
Then they clam up and use double-talk and change the subject.

Fuck you. The simulation must be complete. The steps that follow and
weren't simulated at all were "simulated incorrectly".

Yes I forgot that another part of this double-talk, clamming up and
changing the subject is erasing the original question.

I erased only the misleading assembly code that you spam everywhere.
 

void DDD()
{
    H0(DDD);
}
_DDD()
[000020a2] 55         push ebp      ; housekeeping
[000020a3] 8bec       mov ebp,esp   ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404     add esp,+04   ; housekeeping
[000020b2] 5d         pop ebp       ; housekeeping
[000020b3] c3         ret           ; never gets here
Size in bytes:(0018) [000020b3]
>
Exactly which step of DDD emulated by H0 was emulated incorrectly such
that this emulation would be complete?
AKA DDD emulated by H0 reaches machine address [000020b3]

Exactly which steps prevents it from getting there? We know that H0 halts.
 

void DDD()
{
   H0(DDD);
}
_DDD()
[000020a2] 55         push ebp      ; housekeeping
[000020a3] 8bec       mov ebp,esp   ; housekeeping
[000020a5] 68a2200000 push 000020a2 ; push DDD
[000020aa] e8f3f9ffff call 00001aa2 ; call H0
[000020af] 83c404     add esp,+04   ; housekeeping
[000020b2] 5d         pop ebp       ; housekeeping
[000020b3] c3         ret           ; never gets here
Size in bytes:(0018) [000020b3]
Exactly which step of DDD emulated by H0 was emulated
incorrectly such that this emulation would be complete?
AKA DDD emulated by H0 reaches machine address [000020b3]
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer