Re: Title: A Structural Analysis of the Standard Halting Problem Proof

On 7/25/2025 12:30 PM, Richard Damon wrote:

On 7/25/25 12:44 PM, olcott wrote:

On 7/25/2025 3:49 AM, Fred. Zwarts wrote:

Op 23.jul.2025 om 15:31 schreef olcott:

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

Op 23.jul.2025 om 06:05 schreef olcott:

On 7/22/2025 9:32 PM, Richard Damon wrote:

>
No, YOU changed the subject of the problem from the OBJECTIVE behavior of the execution of DDD, to the SUBJECTIVE criteria of what HHH sees.
>

>
It is always the case that every halt decider is
only accountable for the behavior that its actual
input specifies and not accountable for the behavior
of any non-inputs. The textbooks don't do it this
way proves that textbooks are wrong.

>
As usual irrelevant claim without evidence
Up to now you could not point to any textbook that is wrong.
>

>
Textbooks incorrectly assume that the behavior specified
by the finite string machine description of ⟨M⟩ is always
the same as the behavior of machine M. That is not the
case when M calls its own termination analyzer.

>
As usual repeated claims without any evidence.
The behaviour specified in the description of the input does not depend on who analyses it. When some analysers are unable to see the whole specification, that is an error in the analyser, it does not change the specification.
>

>
Turing machine halt deciders compute the mapping from
their input finite strings to the behavior that these
finite strings specify.

>
Exactly.
And when a halting behaviour is specified, but the analyser is unable to see that, the analyser is wrong. It should not compute the behaviour of a hypothetical non-halting non-input.
>

>

>
*Its been three years now and you can't remember*
<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>
>
>

>
Repeating the agreement with a vacuous statement is no rebuttal.
Since there is no H that correctly simulates D until it correctly detects that its D would never stop unless aborted', the conclusion is irrelevant.
>

>
_DD()
[00002162] 55             push ebp
[00002163] 8bec           mov ebp,esp
[00002165] 51             push ecx
[00002166] 6862210000     push 00002162 // push DD
[0000216b] e862f4ffff     call 000015d2 // call HHH
[00002170] 83c404         add esp,+04
[00002173] 8945fc         mov [ebp-04],eax
[00002176] 837dfc00       cmp dword [ebp-04],+00
[0000217a] 7402           jz 0000217e
[0000217c] ebfe           jmp 0000217c
[0000217e] 8b45fc         mov eax,[ebp-04]
[00002181] 8be5           mov esp,ebp
[00002183] 5d             pop ebp
[00002184] c3             ret
Size in bytes:(0035) [00002184]

>
>
You have been told many times that these 35 bytes are not the complete input. In fact they are the least interesting part of the input. DD is completely irrelevant. What is relevant is that HHH must simulate itself.
>
        int main() {
          return HHH(main);
        }
>
Here is no DD, and your own words are that HHH returns and reports that it does not halt.
This clearly shows that HHH is unable to analyse its own behaviour and produces false negative when it tries to do so.
>

>
When-so-ever the input to a simulating termination
analyzer calls its actual self as (your example above)
or when the HHH(DDD) input calls HHH(DDD) this does
specify recursive emulation that must be aborted to
prevent the non-termination of the directly executed HHH.
>

 Where do you get this claim from?
 

If you understood recursion well enough you
could have figured this out on your own
as four different chatbots did figure this
out on their own.

REMEMBER the problem order, HHH existed first, and can't change to avoid problems, THEN we create the input DDD, which uses that SPECIFIC HHH.
 The template DDD might have existed first, but not the program DDD, and the input is of the PROGRAM.
 Either it aborted in this condition, at which the program that calls it can use that fact to establish that it will halt,
 or it doesn't abort, and then fails in the way you describe.
 HHH can't treat the input that calls this HHH (that aborts) as calling some other code (a version that does).
 All you are doing is showing that your "logic" is based on lying.

All that the above shows is that you don't understand
recursion well enough. If you did understand recursion
well enough you would understand that the input to HHH(DDD)
does specify the recursive emulation non-halting behavior
pattern.
_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]
The conclusive proof that I am right and you are
wrong is provided by the correct execution trace
of DDD emulated by HHH.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer