From Newsgroup: sci.logic

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-a-a-a-a-a-a-a-a-a-a-a-a push ebp
[00002193] 8bec-a-a-a-a-a-a-a-a-a-a mov ebp,esp
[00002195] 6892210000-a-a-a-a push 00002192-a // push DDD
[0000219a] e833f4ffff-a-a-a-a call 000015d2-a // call HHH
[0000219f] 83c404-a-a-a-a-a-a-a-a add esp,+04
[000021a2] 5d-a-a-a-a-a-a-a-a-a-a-a-a pop ebp
[000021a3] c3-a-a-a-a-a-a-a-a-a-a-a-a 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.
--- Synchronet 3.21a-Linux NewsLink 1.2