Re: My reviewers think that halt deciders must report on the behavior of their caller --- Mike

On 7/11/25 5:27 PM, olcott wrote:

On 7/11/2025 9:31 AM, Fred. Zwarts wrote:

Op 11.jul.2025 om 16:27 schreef olcott:

On 7/11/2025 3:55 AM, Fred. Zwarts wrote:

Op 11.jul.2025 om 04:33 schreef olcott:

On 7/10/2025 9:10 PM, Richard Damon wrote:

On 7/10/25 8:27 PM, olcott wrote:

*I just proved the fact that*
(1) HHH(DDD) is executed
(2) HHH emulates DDD
(3) emulated DDD calls an emulated HHH(DDD)
(4) emulated HHH emulates another instance of DDD
(5) this DDD calls HHH(DDD) again
https://liarparadox.org/HHH(DDD)_Full_Trace.pdf
>
Its OK if you are no good with the x86 language
and can't understand the code. I began programming
way back when x86 programming was popular.
>
Alternatively the details of how multi-tasking
works are too difficult for you. They are probably
too difficult for most programmers.
>

>
And thus you have proven my point that either you definition of what the input is, or what HHH does is just a lie.
>
But, it seems you are too stupid to understand that problem.
>
Your claims are:
>
1) The input contains only the code shown, and thus does not contain the code of HHH.
>
2) That HHH is simulating the input given to it, and thus JUST that input.
>
3) That HHH simulates the code of HHH.
>

>
The test program HHH is not the program under test DDD.
The program under test and the test program will never
stop running unless HHH aborts its DDD.
>

>
Another vague claim without evidence.

>
It not vague at all. You just don't know what
the words mean.
>

If DDD is under test, then also all function called by DDD are under test, including HHH.

>
Since neither HHH nor DDD will ever stop running
unless HHH aborts its DDD, non-halting criteria
has been met.

>
Since HHH halts, DDD halts, too.

 Sure if you lie about which DDD is being referred to.

So, What DDD are you talking about?
To be the equivalent of the proof program, it needs to be an actual program that includes the code of the decider it was built to foil.
And that doesn't change for a given DDD. Yes, we can build a DIFFERENT DDD for some other decider, but each proof program is built for only one decider.
The proof then works on a universally arguement to show that since we can build a different proof program for any decider we might think about, every decider we might think up has a proof program that it will get wrong, and thus no decider gets the right answer for every possible input, since the proof program built on it IS a valid input to give to it, and it will get that one wrong.
It seem you think all the proof programs are the "same", but they aren't. They are built from the same template, but deciders don't decide on templates, they decide on programs.

 

So, there are no halting criteria. That HHH does not see that the input specifies a halting program is a failure of HHH, not a correct halting criterium.
>

>

You are confusing yourself with the construct where the program under test is in the same memory as the program being tested. It would be much easier to understand for you to keep the input for HHH separated from HHH, by using a copy of HHH in the input.

>
To divide the analysis of the program under test
from the test program we only see if DDD simulated
by HHH can reach its own simulated final halt state.
>
>

>
But HHH called by DDD is part of the program and cannot correctly be separated from it.

 Neither HHH nor DDD ever stop running unless HHH
aborts its simulation of DDD. If you have no idea
what recursion is you won't ever get this.
 

ANd since you HHH does abort its simulation to answer, and its DDD is built on it, that DDD will also call an HHH that returns and thus DDD Halts.
The fact that the DIFFERENT DDD built of the DIFFERENT HHH that doesn't abort is irrelvent, as that isn't what the input is supposed to be.
Of course, since your arguement is just based on lies, you try to lie by claiming all the DDD are the same, when they are just all built on the same template, and we aren't deciding on the template.
You are just proving that you are just a pathological liar.