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. 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)

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:

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*

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 the abort is not commented out in the running code!

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

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

On Tue, 30 Jul 2024 16:13:55 -0500, olcott <[email protected]>
wrote:

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:

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*

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 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.

Which means that it works in some cases, not all cases
Which means it doesn't work universally

So it's not a general solution to the halting problem

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

On 7/30/24 5:13 PM, olcott wrote:

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:

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*

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 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.

But then it is a different input, as the code for the HHH that it calls
MUST be considered as part of the input.

So, you are just proving yourself to be a stupid liar.

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)

Op 30.jul.2024 om 22:05 schreef 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:

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.

Only because you are cheating and not only change the simulator, but
also the input.
The input is HHH that aborts and halts.
It is irrelevant that another input, the HHH, that does not abort does
not halt.
But when the HHH that aborts and halts is correctly simulated, e.g. by
HHH1, than we see that the simulation halts without the need to abort.
It is only because you keep dreaming of a HHH that does not abort, that
you think an abort is needed for a HHH that *does* abort and halt.
Stop dreaming about the HHH that does not halt. Dreams are no substitute
for logic proofs.

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

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 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).

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Op 30.jul.2024 om 23:13 schreef 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:

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*

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 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.

So you proved that it can only produce a correct prediction for another
input: the HHH that does not halt.
But when it must predict the behaviour of HHH that aborts and halts, it
fails.
You think that is correct, because you are still dreaming of that other
HHH that does not halt. Dreams are no substitute for logic proofs.

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

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program. You changed only the inner
HHH's, not the outermost one, thus breaking the recursive simulation.

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.

A program's identity changes with its code. It doesn't matter what I label
it in the source. I can define different functions with the same name.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH.

You changed only the inner HHH's, not the outermost one, thus breaking
the recursive simulation.

Not at all. I simply disabled the abort and this resulted in unlimited repetition non-halting behavior.

You did NOT change all calls to HHH.

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).

A program's identity changes with its code. It doesn't matter what I
label it in the source. I can define different functions with the same
name.

To prove that a section of code is required we remove that section and
the resulting endless repetition proves that the abort section was
required to prevent the endless repetition.

Enough said.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH.

Yet this is unreachable in the same way that in a single file
foot race with everyone going the same speed and everyone
15 feet ahead of the next person that the first person must win.

Yet that is no reason for the person in front to kill all other people,
because otherwise they would not stop running.
The first person will stop at the finish, the second person will stop at
the finish, the third .... etc.

There is no reason to assume that there are persons that will keep
running indefinitely.

The outermost HHH sees that it must abort one whole execution
trace sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have halted
when not aborted. This is proved when HHH is simulated by a non-aborting simulator, such as HHH1. A correct simulation shows that the simulated
HHH does not need to be aborted.

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

Am Wed, 31 Jul 2024 16:27:58 -0500 schrieb olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH.

Yet this is unreachable in the same way that in a single file foot
race with everyone going the same speed and everyone 15 feet ahead of
the next person that the first person must win.

Yet that is no reason for the person in front to kill all other people,
because otherwise they would not stop running.
The first person will stop at the finish, the second person will stop
at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep
running indefinitely.

They will run unto the finish.

The outermost HHH sees that it must abort one whole execution trace
sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have halted
when not aborted.

It has never been an assumption is has always been a tautology that has always been over your head. Joes may be catching up with the Linz proof.

If one of them aborts, all of them do.

This is proved when HHH is simulated by a non-aborting simulator, such
as HHH1. A correct simulation shows that the simulated HHH does not
need to be aborted.

When we remove the abort code it keeps repeating. When we don't remove
the abort code it gets aborted.

Also, the simulated HHH aborts and the simulating HHH doesn't trigger.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

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. HHH cannot possibly simulate
itself correctly.
So you made the same error thousands of times.
You never showed a correct definition.

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

Op 31.jul.2024 om 23:27 schreef olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH.

Yet this is unreachable in the same way that in a single file
foot race with everyone going the same speed and everyone
15 feet ahead of the next person that the first person must win.

Yet that is no reason for the person in front to kill all other
people, because otherwise they would not stop running.
The first person will stop at the finish, the second person will stop
at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep
running indefinitely.

The outermost HHH sees that it must abort one whole execution
trace sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have halted
when not aborted.

It has never been an assumption is has always been a
tautology that has always been over your head. Joes
may be catching up with the Linz proof.

This is proved when HHH is simulated by a non-aborting simulator, such
as HHH1. A correct simulation shows that the simulated HHH does not
need to be aborted.

When we remove the abort code it keeps repeating.

But then you also changed the input.
A better proof is the simulation of HHH by HHH1, which shows that no
abort is needed to simulate HHH.

When we don't remove the abort code it gets aborted.
An average first year comp sci student can get this.

We are discussion the input given to HHH of a HHH that aborts.
You are changing the subject to another input
A better idea would be to change
if (Root)
to
if (!Root)
in the code of HHH

that would come close to a simulator that does not abort which simulates
a HHH that does abort. That one will show you that no abort is needed.

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

On 2024-08-01 04:03:36 +0000, wij said:

int main()
{
   HHH(DDD);
}

That is not very useful. Running this program may demostrate that
HHH answers but does not reveal the answer. The program should be:

void output(char *); // in Olcott's library

int main () {
output("Asking HHH whether DDD will halt.");
int ans = HHH(DDD);
if (ans) {
output("HHH predicts that DDD will halt.");
} else {
output("HHH predicts that DDD will not halt.");
}
output("Running DDD");
DDD();
output("DDD halted");
return ans;
}

--
Mikko

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

On 7/31/24 11:51 PM, olcott wrote:

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 only *IF* HHH *DOES* correctly emulate its input, which means it
can't abort its emulation, which means it isn't a decider.

since HHH is part of the input DDD, or you are just admitting you have
been lying for years about working in computation theory, changing it,
gives you a new DDD, with possibly different behavior. So the DDD which
calls an HHH that DOES abort might be halting even though the DDD that
calls an HHH that doesn't abort is non-halting, and in fact is.

You are just proving you are nothing but a pathetic ignorant
pathological lying idiot that reckless disregards the truth to promote
your lies, like like the election deniers and climate change deniers, so
you can't be fighting them since you are supporting them.

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

Op 01.aug.2024 om 13:20 schreef olcott:

On 8/1/2024 2:18 AM, joes wrote:

Am Wed, 31 Jul 2024 16:27:58 -0500 schrieb olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH.

Yet this is unreachable in the same way that in a single file foot
race with everyone going the same speed and everyone 15 feet ahead of >>>>> the next person that the first person must win.

Yet that is no reason for the person in front to kill all other people, >>>> because otherwise they would not stop running.
The first person will stop at the finish, the second person will stop
at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep
running indefinitely.

They will run unto the finish.

The outermost HHH sees that it must abort one whole execution trace
sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have halted >>>> when not aborted.

It has never been an assumption is has always been a tautology that has
always been over your head. Joes may be catching up with the Linz proof.

If one of them aborts, all of them do.

If the outer one waits for the next inner one then they all
wait for their own next inner one and none of them ever abort.

Indeed! It seems you now almost understand it.
The outer one doesn't wait for the inner one, because it is programmed
to abort.
Therefore, the outer one is incorrect, because it does not wait.
This proves that it is impossible to create a HHH that simulates itself correctly.
If it waits it is incorrect, if it doesn't wait it is incorrect, too.
It shows that the idea of HHH simulating itself is not a clever idea.
HHH cannot possibly simulate itself correctly.

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

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

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 since HHH deviates from the semantics of the x86 language (by
skipping instructions of a halting program) it is incorrect.

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

Op 01.aug.2024 om 14:32 schreef olcott:

On 8/1/2024 6:36 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 13:20 schreef olcott:

On 8/1/2024 2:18 AM, joes wrote:

Am Wed, 31 Jul 2024 16:27:58 -0500 schrieb olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH. >>>>>>>>

Yet this is unreachable in the same way that in a single file foot >>>>>>> race with everyone going the same speed and everyone 15 feet
ahead of
the next person that the first person must win.

Yet that is no reason for the person in front to kill all other
people,
because otherwise they would not stop running.
The first person will stop at the finish, the second person will stop >>>>>> at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep >>>>>> running indefinitely.

They will run unto the finish.

The outermost HHH sees that it must abort one whole execution trace >>>>>>> sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have
halted
when not aborted.

It has never been an assumption is has always been a tautology that
has
always been over your head. Joes may be catching up with the Linz
proof.

If one of them aborts, all of them do.

If the outer one waits for the next inner one then they all
wait for their own next inner one and none of them ever abort.

Indeed! It seems you now almost understand it.
The outer one doesn't wait for the inner one, because it is programmed
to abort.
Therefore, the outer one is incorrect, because it does not wait.

The emulation is correct if and only if it is according
to the semantics of the x86 language. At this point it
seems that you have been a Troll all along.

No, you are a slow learner. It has been pointed out to you already many
times that HHH deviates from the semantics of the x86 language when it
skips instructions of a halting program.
So according to the criterion you mention, it is incorrect.

If HHH waits it is incorrect, if it does not wait it aborts too soon,
which is incorrect as well.

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

Op 01.aug.2024 om 14:01 schreef olcott:

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

Op 31.jul.2024 om 23:27 schreef olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH.

Yet this is unreachable in the same way that in a single file
foot race with everyone going the same speed and everyone
15 feet ahead of the next person that the first person must win.

Yet that is no reason for the person in front to kill all other
people, because otherwise they would not stop running.
The first person will stop at the finish, the second person will
stop at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep
running indefinitely.

The outermost HHH sees that it must abort one whole execution
trace sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have
halted when not aborted.

It has never been an assumption is has always been a
tautology that has always been over your head. Joes
may be catching up with the Linz proof.

This is proved when HHH is simulated by a non-aborting simulator,
such as HHH1. A correct simulation shows that the simulated HHH does
not need to be aborted.

When we remove the abort code it keeps repeating.

But then you also changed the input.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    If simulating *halt decider H correctly simulates its input D*
    *until H correctly determines that its simulated D would never*
    *stop running unless aborted* then

    H can abort its simulation of D and correctly report that D
    specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Changing to an irrelevant other subject. Sipser agreed only to correct simulations. HHH, when it aborts, is a halting program.
You are running in circles, because it seems you forget what has been
pointed out to you.
No matter how often you repeat it, your dreams will not be a substitute
for logic.

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

Op 01.aug.2024 om 15:04 schreef olcott:

On 8/1/2024 7:56 AM, Fred. Zwarts wrote:

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

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 since HHH deviates from the semantics of the x86 language (by
skipping instructions of a halting  program) it is incorrect.

Only a freaking moron would believe that a non
terminating input should be simulated forever.

We are not talking about your dreams of a non aborting HHH. We are
talking about an aborting HHH which terminates.
So, who is the freaking moron talking about non-terminating input?
Dreams are no substitute for fact or for logic.
Skipping the last cycle of the simulation of HHH, which aborts after two cycles, is a deviation from the semantics of the x86 language.
But, you are a slow learner. Probably you will repeat the same error
another thousand times.

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

Op 01.aug.2024 om 15:07 schreef olcott:

On 8/1/2024 7:59 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 14:32 schreef olcott:

On 8/1/2024 6:36 AM, Fred. Zwarts wrote:

Op 01.aug.2024 om 13:20 schreef olcott:

On 8/1/2024 2:18 AM, joes wrote:

Am Wed, 31 Jul 2024 16:27:58 -0500 schrieb olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required. >>>>>>>>>> When you put in the abort, it also appears in the simulated HHH. >>>>>>>>>>

Yet this is unreachable in the same way that in a single file foot >>>>>>>>> race with everyone going the same speed and everyone 15 feet >>>>>>>>> ahead of
the next person that the first person must win.

Yet that is no reason for the person in front to kill all other >>>>>>>> people,
because otherwise they would not stop running.
The first person will stop at the finish, the second person will >>>>>>>> stop
at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep >>>>>>>> running indefinitely.

They will run unto the finish.

The outermost HHH sees that it must abort one whole execution >>>>>>>>> trace
sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have >>>>>>>> halted
when not aborted.

It has never been an assumption is has always been a tautology
that has
always been over your head. Joes may be catching up with the Linz >>>>>>> proof.

If one of them aborts, all of them do.

If the outer one waits for the next inner one then they all
wait for their own next inner one and none of them ever abort.

Indeed! It seems you now almost understand it.
The outer one doesn't wait for the inner one, because it is
programmed to abort.
Therefore, the outer one is incorrect, because it does not wait.

The emulation is correct if and only if it is according
to the semantics of the x86 language. At this point it
seems that you have been a Troll all along.

No, you are a slow learner. It has been pointed out to you already
many times that HHH deviates from the semantics of the x86 language
when it skips instructions of a halting program.

You are simply too stupid to understand the execution trace.

Irrelevant nonsense ignored. No relevant content detected.

So according to the criterion you mention, it is incorrect.

If HHH waits it is incorrect, if it does not wait it aborts too soon,
which is incorrect as well.

--
Paradoxes in the relation between Creator and creature. <http://www.wirholt.nl/English>.

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

Op 01.aug.2024 om 15:08 schreef olcott:

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

Op 01.aug.2024 om 14:01 schreef olcott:

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

Op 31.jul.2024 om 23:27 schreef olcott:

On 7/31/2024 3:09 PM, Fred. Zwarts wrote:

Op 31.jul.2024 om 18:32 schreef olcott:

On 7/31/2024 11:17 AM, joes wrote:

Am Wed, 31 Jul 2024 10:02:26 -0500 schrieb olcott:

On 7/31/2024 9:16 AM, joes wrote:

Am Wed, 31 Jul 2024 05:52:54 -0500 schrieb olcott:

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.

Commenting out a section changes the program.

This conclusively proving that this section was required.

When you put in the abort, it also appears in the simulated HHH. >>>>>>>>

Yet this is unreachable in the same way that in a single file
foot race with everyone going the same speed and everyone
15 feet ahead of the next person that the first person must win.

Yet that is no reason for the person in front to kill all other
people, because otherwise they would not stop running.
The first person will stop at the finish, the second person will
stop at the finish, the third .... etc.

There is no reason to assume that there are persons that will keep >>>>>> running indefinitely.

The outermost HHH sees that it must abort one whole execution
trace sooner than the next inner HHH.

But it is wrong to assume that the simulated HHH would not have
halted when not aborted.

It has never been an assumption is has always been a
tautology that has always been over your head. Joes
may be catching up with the Linz proof.

This is proved when HHH is simulated by a non-aborting simulator,
such as HHH1. A correct simulation shows that the simulated HHH
does not need to be aborted.

When we remove the abort code it keeps repeating.

But then you also changed the input.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating *halt decider H correctly simulates its input D*
     *until H correctly determines that its simulated D would never* >>>      *stop running unless aborted* then

     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Changing to an irrelevant other subject. Sipser agreed only to correct
simulations.

Correct simulations *until* you damned liar.

Irrelevant ad hominem attack ignored. It shows the lack of arguments.
The 'until' is not fulfilled, because there is no D that never stops
running. HHH when simulated by itself, would abort and stop after two
cycles, after which DDD would stop as well. This shows that the words 'correctly determines' cannot be used.
So, the whole sentence is vacuous word salad.
It is easy to agree with properties of a non-existing thing.

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

Am Thu, 01 Aug 2024 08:04:23 -0500 schrieb olcott:

On 8/1/2024 7:56 AM, Fred. Zwarts wrote:

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

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 !!!

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 since HHH deviates from the semantics of the x86 language (by
skipping instructions of a halting  program) it is incorrect.

Only a freaking moron would believe that a non terminating input should
be simulated forever.

I mean, how many iterations of an infinite loop can I skip simulating or
how many do I have to simulate to get identical behaviour?

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

Am Thu, 01 Aug 2024 10:50:29 -0500 schrieb olcott:

On 8/1/2024 10:44 AM, joes wrote:

Am Thu, 01 Aug 2024 08:04:23 -0500 schrieb olcott:

On 8/1/2024 7:56 AM, Fred. Zwarts wrote:

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

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 !!!

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 since HHH deviates from the semantics of the x86 language (by
skipping instructions of a halting  program) it is incorrect.

Only a freaking moron would believe that a non terminating input
should be simulated forever.

I mean, how many iterations of an infinite loop can I skip simulating
or how many do I have to simulate to get identical behaviour?

When one disables the abort code then the cycle never stops.

When one introduces it, it becomes unnecessary, because the cycle stops
from the INSIDE.
After how many repetitions can infinite recursion be aborted before
the simulation becomes wrong?

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.

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

On 8/1/24 8:30 AM, olcott wrote:

On 8/1/2024 6:34 AM, Richard Damon wrote:

On 7/31/24 11:51 PM, olcott wrote:

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 only *IF*  HHH *DOES* correctly emulate its input, which means it
can't abort its emulation,

*No stupid it has never meant that*

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
    *simulating halt decider H correctly simulates its input D*
    *until H correctly determines that its simulated D would never*
    *stop running unless aborted*
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Really, do you have a source for that?

I say it does, and that follows from the DEFINITION of the only thing
described in Computation theory as a "correct simulator", which is the
UTM, which BY DEFINITION behaves EXACTLY like the machine it is
simulating, even if that machine is non-halting, thus it can not abort
its simulation.

You r claim is just another your your uncounted false claims that you
have absolutely no support for, and don't even try to justify, because
you know you are just making them up.

Sorry, you are just proving yourself to be a LIAR.

I will say, your subject at least is honest this time, the CORRECT
answer for HHH is to say Halting, unfortunatly, that isn't what it says.

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

On 2024-08-01 12:28:51 +0000, olcott said:

On 8/1/2024 3:33 AM, Mikko wrote:

On 2024-08-01 04:03:36 +0000, wij said:

int main()
{
   HHH(DDD);
}

That is not very useful. Running this program may demostrate that
HHH answers but does not reveal the answer. The program should be:

[Hypothetical possibilities --- Complete Proof]
On 8/1/2024 7:20 AM, olcott
The above has complete proof for every expert of
the x86 language.

A very limited target audience and eve more limited if you exclude
those that don't care about the topic.

--
Mikko

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

On 2024-08-01 11:51:45 +0000, olcott said:

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.

When HHH does not do what-ever-the-hell the x86 semantics specifies
the HHH is incorrect.

--
Mikko

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