Re: Liar detector: Fred, Richard, Joes and Alan --- Ben's agreement

On 7/9/2024 1:14 AM, Mikko wrote:

On 2024-07-08 17:36:58 +0000, olcott said:
 

On 7/8/2024 11:16 AM, Fred. Zwarts wrote:

Op 08.jul.2024 om 18:07 schreef olcott:

>
Try to show how infinity is one cycle too soon.
>

You believe that two equals infinity.

>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
void Infinite_Recursion()
{
   Infinite_Recursion();
}
>
void DDD()
{
   HHH(DDD);
}
>
Two cycles is enough to correctly determine that none
of the above functions correctly emulated by HHH can
possibly halt.
>
That you don't see this is ignorance or deception.

 There is an important detail that determines whether an infinite
execution can be inferred. That is best illustrated by the following
examples:
 void Finite_Loop()
{
   int x = 10000;
HERE:
   if (x > 0) {
     x--;
     goto HERE;
   }
}
 void Finite_Recursion(int n)
{
   if (n > 0) {
     Finite_Recursion(n + 1);
   }
}
 void DDD()
{
   HHH(DDD); // HHH detects recursive simulation and then simulates no more
}
 The important difference is that in my examples there is a conditional
instruction that can (and does) prevent infinite exectuion.
 

When we ask:
Does the call from DDD emulated by HHH to HHH(DDD) return?
We find that the emulated HHH never returns and this causes
the emulated DDD to never halt.
_DDD()
[00002163] 55         push ebp      ; housekeeping
[00002164] 8bec       mov ebp,esp   ; housekeeping
[00002166] 6863210000 push 00002163 ; push DDD
[0000216b] e853f4ffff call 000015c3 ; call HHH(DDD)
[00002170] 83c404     add esp,+04
[00002173] 5d         pop ebp
[00002174] c3         ret
Size in bytes:(0018) [00002174]
DDD is correctly emulated by HHH which calls an emulated
HHH(DDD) to repeat this process until the emulated DDD is
aborted. At no point in this emulation does the call from
DDD correctly emulated by HHH to HHH(DDD) ever return.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer