Re: The error of the standard proof of the halting problem

Op 23.jul.2025 om 14:57 schreef olcott:

On 7/23/2025 3:20 AM, Fred. Zwarts wrote:

Op 22.jul.2025 om 18:09 schreef olcott:

On 7/22/2025 3:45 AM, Fred. Zwarts wrote:

Op 22.jul.2025 om 06:17 schreef olcott:

On 7/21/2025 9:20 PM, Richard Damon wrote:

On 7/21/25 9:45 AM, olcott wrote:

On 7/21/2025 4:06 AM, Mikko wrote:

On 2025-07-20 11:48:37 +0000, Mr Flibble said:
>

On Sun, 20 Jul 2025 07:13:43 -0400, Richard Damon wrote:
>

On 7/20/25 12:58 AM, olcott wrote:

Title: A Structural Analysis of the Standard Halting Problem Proof
>
Author: PL Olcott
>
Abstract:
This paper presents a formal critique of the standard proof of the
undecidability of the Halting Problem. While we do not dispute the
conclusion that the Halting Problem is undecidable, we argue that the
conventional proof fails to establish this conclusion due to a
fundamental misapplication of Turing machine semantics. Specifically,
we show that the contradiction used in the proof arises from conflating
the behavior of encoded simulations with direct execution, and from
making assumptions about a decider's domain that do not hold under a
rigorous model of computation.
>

Your problem is you don't understand the meaning of the words you are
using.

>
This is an ad hominem attack, not argumentation.

>
It is also honest and truthful, which is not as common as it should.
>

>
It is also honest and truthful that people
that deny verified facts are either liars
or lack sufficient technical competence.
>

>
Right, so YOU are the liar.
>
It is a verified fact that the PROGRAM DDD halts since your HHH(DDD) returns 0.
>

>
It is a self-evident truth that the halting problem proof
has always been incorrect when it requires a halt decider
to report on the behavior of the direct execution of any
Turing machine because no Turing machine decider can ever
take another directly executed Turing machine as its input.

As usual incorrect claims without evidence.
Nobody requires the halt decider to report on another direct execution.

>
counter-factual

>
As usual incorrect claims without evidence.
>

>
The *domain of this problem is to be taken as the*
*set of all Turing machines* [WRONG] and all w;
>

 The domain of the problem is not *set of all Turing machines*
it is the *set of all finite string Turing machine descriptions*

Note the word 'descriptions'.

 

that is, we are
looking for a single Turing machine that, given the
description of an arbitrary M and w, will predict
whether or not the computation of M applied to w will halt.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

>
Note the 'given the description of an arbitrary M". It does not say 'given an arbitrary M'. The word 'description' makes your claim counter- factual.
>

>

The halt decider must decide on its input. In this case the input specifies a DD that calls a HHH that aborts and returns, so the input specifies a halting program.

>
The simulated DDD that calls a simulated HHH(DDD)
never aborts or returns.

>
But the HHH called by DDD is programmed to abort after a finite recursion. The behaviour of DDD depends on the behaviour of HHH. When HHH returns with a value of 0, DDD reaches the final halt state.
That is what is specified. That is what a correct simulation would see.
>

 _DDD()
[00002192] 55             push ebp
[00002193] 8bec           mov ebp,esp
[00002195] 6892210000     push 00002192  // push DDD
[0000219a] e833f4ffff     call 000015d2  // call HHH
[0000219f] 83c404         add esp,+04
[000021a2] 5d             pop ebp
[000021a3] c3             ret
Size in bytes:(0018) [000021a3]
 *This is a verified fact*

that these 18 bytes are not the whole program. The whole program includes all functions called directly or indirectly by DDD, in particular the HHH that has code to abort after a finite number of recursions. Then it returns with a value of 0 to DDD, which then reaches the final halt state. This means that the input specifies a halting program.
Therefore, indeed:

*Any disagreement proves lack of understanding*

 The fact that no DDD emulated by HHH according to the
semantics of the x86 language can possibly reach its
own simulated "ret" instruction final halt state proves
that DDD specifies non-halting behavior.

No, it proves that HHH fails to follow correctly the semantics of the x86 language, by doing a premature abort. World-class simulators using the exact same input, but without premature abort, prove that a correct simulation reaches the final halt state.
HHH, by doing a premature abort, fails to reach that final halt state.
It makes no sense to repeat this failure of HHH again and again.