Re: ChatGPT explains why rebuttals of my work are incorrect

On 16/10/2024 21:41, Chris M. Thomasson wrote:

On 10/15/2024 6:43 PM, Mike Terry wrote:

On 14/10/2024 23:17, Chris M. Thomasson wrote:

On 10/13/2024 7:57 PM, olcott wrote:

On 10/13/2024 11:34 AM, Kaz Kylheku wrote:

On 2024-10-12, Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:

On 10/12/2024 11:28 AM, Janis Papanagnou wrote:

On 12.10.2024 11:32, Jan van den Broek wrote:

2024-10-12, Chris M. Thomasson <chris.m.thomasson.1@gmail.com> schrieb:

On 10/11/2024 7:50 PM, olcott wrote:

>
[Schnipp]
>
As I see it, the main Halting Problem is Olcott not halting.

>
LOL! - A very nice one. Thanks for that. :-)

>
I second that. :^)

>
You're likely thousand-seconding that. The Olcott not halting joke
is many years old now, and will likely come up again.
>
>

>
My cancer has gotten worse.
>
*ChatGPT explains why rebuttals of my work are incorrect*
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
>
I had to dumb this down from the original halting problem
input so that reviewers can verify that HHH is correct
without hardly paying any attention at all:
>
void DDD()
{
   HHH(DDD);
   return;
}
>
When HHH is an x86 emulation based termination analyzer
then each DDD emulated by any HHH that it calls never returns.

[...]
>
Isn't that similar to:
>
void foobar()
{
     foobar();
}
>
? >

>
Similar, but different because HHH only performs a /partial/ step by step emulation of DDD - it stops emulating after a while and returns, so DDD() halts.  foobar() will never halt (ignoring physical resource constraints like running out of stack).  foobar() undergoes infinite recursive call.  DDD() exhibits /finite/ recursive emulation, then halts.

 So, any similar to:
______________
void foo(
     unsigned long ri,
     unsigned long rn
) {
     if (ri > rn) return;
     foo(ri + 1, rn);
}
______________
 foo(0, 5);
 ?

Yes - similar in that both :
-  foo and PO's DDD exhibit a flavour of recursion, and
-  both foo and DDD break the recursion at some point and subsequently halt
Different in that:
-  foo exhibits "recursive call" while DDD exhibits "recursive simulation".
When a call is made, the caller cannot receive control until the callee returns.  So with call recursion, for the pattern to break, the break has to occur at the innermost call - like with your foo.
When a simulation is made, the simulator is still in control, probably running a loop that simulates each individual instruction of the simulated computation.  So recursive simulation may break in the same way as your foo, namely from the inner simulation then percolating back through the nested simulations until the outer simulation exits.  Also it can break by one of the simulations simply deciding not to continue its simulation any more and quiting its instruction simulation loop. That's what PO's DDD does.
Another example:  Suppose GGG is coded to simulate 10000000 instrucions of GGG then exit.  That is more similar to DDD than your foo, because like DDD it exhibits recursive simulation, and like DDD the recursion breaks from the outside.  Everybody agrees that GGG terminates - would you be tempted to say that it is correct to say GGG never halts because it "exhibits infinitely recursive behaviour"?  [meaning that the combined GGG emulation trace shows that simulated GGG simulates the exact same GGG again].  I doubt that!  (The whole idea is beyond stupid, given we agree GGG halts.)
Mike.