On 7/30/24 4:05 PM, olcott wrote:

On 7/30/2024 1:48 PM, Fred. Zwarts wrote:

Op 30.jul.2024 om 17:14 schreef olcott:

On 7/30/2024 9:51 AM, Fred. Zwarts wrote:

Op 30.jul.2024 om 16:21 schreef olcott:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 >>>>> [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 >>>>> [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
[00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

We all see the differences between these two.

They both correctly predict behavior that must be aborted to
prevent the infinite execution of the simulating halt decider.

Except that the prediction for the second one is wrong. The simulation
of an aborting and halting function, like HHH, does not need to be
aborted.

I proved otherwise. When the abort code is commented out
then it keeps repeating again and again, thus conclusively
proving that is must be aborted or HHH never halts.

But that changes the input program, so is an INVALID transform.

This is proved when it is simulate by HHH1. HHH aborts after two
recursions, which is not an infinite execution.

We know you really, really wants it to be correct. So, you are
cheating by suppressing part of the trace, in order to hide the
conditional branch instructions in the second case. But no matter how
much olcott wants it to be correct, or how many times olcott repeats
that it is correct, it does not change the fact that such a simulation
is incorrect

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 7/31/24 6:52 AM, olcott wrote:

On 7/31/2024 3:54 AM, joes wrote:

Am Tue, 30 Jul 2024 16:13:55 -0500 schrieb olcott:

On 7/30/2024 4:07 PM, joes wrote:

Am Tue, 30 Jul 2024 15:05:54 -0500 schrieb olcott:

On 7/30/2024 1:48 PM, Fred. Zwarts wrote:

Op 30.jul.2024 om 17:14 schreef olcott:

On 7/30/2024 9:51 AM, Fred. Zwarts wrote:

Op 30.jul.2024 om 16:21 schreef olcott:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

I proved otherwise. When the abort code is commented out then it keeps >>>>> repeating again and again, thus conclusively proving that is must be >>>>> aborted or HHH never halts.

But the abort is not commented out in the running code!

I modified the original code by commenting out the abort and it does
endlessly repeat just like HHH correctly predicted.

Yes, and that modification makes HHH not call itself

Not at all. It makes HHH stop aborting DDD.
So that HHH and DDD endlessly repeat.

But it makes a *DIFFERENT* program DDD, that doesn't halt.

You just don't understand what a "Program" actually is, because of your self-imposed IGNORANCE of the FACTS.

but a different
program. You'd need to also comment out the outermost abort; then it
wouldn't halt, but if you change HHH to abort, you change all copies
of it at the same time (to keep the recursive call structure).

If your name is Charlie and your leg gets amputated you
are still yourself, you don't get renamed to Bill.

But programs are different.

People are willful, malleable entities.

Programs are fixed deterministic constructs.

And you are just showing your stupidity.,

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/1/24 7:51 AM, olcott wrote:

On 8/1/2024 2:46 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 05:51 schreef olcott:

On 7/31/2024 10:08 PM, wij wrote:

On Tue, 2024-07-30 at 18:50 -0500, olcott wrote:

It is not supposed to be a general solution to the halting problem.
it only shows how the "impossible" input is correctly determined
to be non halting.

But how do you determine it is non-halting?

As I know you are even unable to define what 'halt' mean !!!

I have done this thousands of times and after someone
has read these thousands of times they say that I never
said it once.

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
}

If DDD correctly emulated by HHH cannot possibly
reach its return instruction then it never halts.

But a correct simulation is impossible.

When HHH does what-ever-the-hell the x86 semantics specifies
then HHH is correct.

But when it doesn't, it is wrong.

Since HHH doesn't know what the call instruction will ACTUALLY do, we
prove that it is the later.

You prove that a call to HHH with the parameter DDD will return 0, so
the fact that HHH decides that isn't what it does means it is just
wrong, and you claiming the wrong answer is right just makes you a
pathological liar.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)