Re: This first time anyone In the entire history of the halting problem derived a correct return value for HHH(DD)

On 12/4/24 11:20 PM, olcott wrote:

There is an 80% chance that I will be alive in one month.
There may be an extended pause in my comments.
I will try to bring a computer to the out of town hospital.
 

And thus a 20% chance you will be dead, and all you will have left to be remembered by are all your LIES and stupid arguments.

On 12/4/2024 8:16 PM, Richard Damon wrote:

On 12/4/24 8:50 PM, olcott wrote:

On 12/4/2024 7:45 PM, Richard Damon wrote:

On 12/4/24 8:41 PM, olcott wrote:

On 12/4/2024 7:31 PM, Richard Damon wrote:

On 12/4/24 8:06 PM, olcott wrote:

On 12/4/2024 6:11 PM, Richard Damon wrote:

On 12/4/24 9:27 AM, olcott wrote:

On 12/3/2024 5:39 PM, Richard Damon wrote:

On 12/3/24 6:08 PM, olcott wrote:

On 12/3/2024 3:03 AM, joes wrote:

Am Mon, 02 Dec 2024 20:48:49 -0600 schrieb olcott:

On 11/28/2024 1:48 PM, joes wrote:

>

You said:
  >>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE ITSELF.

We know that HHH halts. It doesn't simulate itself halting.
>

>
Please try and explain how you are not dishonest what you
try to change the subject from my rebuttal of your statement:
>
 >>> HHH can't simulate itself.
>
That HHH does emulate itself emulating DDD proves
THAT IT CAN DO THIS.
>

>
But only if your think that wrong answer can be right.

>
I did not mention anything about answers my entire
scope is that HHH does emulate itself emulating DDD
thus conclusively proving that HHH can emulated itself
emulating DDD.
>
Whenever you go out-of-scope like this it surely
seems dishonest to me.
>

>
But the behaivor that HHH shows that it has *IS* an "answer",

>
DDD emulated by any HHH according to the semantics of
the x86 language cannot possibly reach its "ret" instruction
whether HHH aborts this emulation after N steps or never aborts.
>
>

>
Just a nonsense sentence, since HHH can't emulate HHH as it isn't given it,

>
Why do you have to keep fucking lying about this?
I could die on the operating table in two weeks!
>

>
What's the lie?
>
Can you point to what I say that is wrong, and a reliable reference that show it?
>
All you have is your own lies to call it a lie.
>
And yes, you might die in two weeks, and the only thing you will have left behind is all your lies.

>
Yes you fucking jackass this conclusively proves that
HHH does emulate itself emulating DDD.
>
https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
>

>
Nope.
>
It proves that your HHH fails to meet its requirement to be pure function

 It proves that HHH does emulate itself emulating DDD.

No, it proves that HHH incorrectly emulates DDD.

 Once we get through this point then we know that DDD
does not halt:
 

But DDD does halt, because when we run DDD, it will halt because your HHH that you show WILL return to it

DDD emulated by any HHH according to the semantics of
the x86 language cannot possibly reach its "ret" instruction
whether HHH aborts this emulation after N steps or never aborts.
*This tells us that DDD emulated by HHH DOES NOT HALT*

But HHH doesn't emulated DDD by that criteria, because it *WILL* abort its emulation, in violation of the semantics of the x86 language, proving tha thar you are nothing but a damned stupid liar.

 We do not begin to examine whether or not HHH found this
answer as a pure function until after we agree with the
prior point.

But why would we agree to a LIE. The alternate *ONLY* HHH that your statement is true is the HHH that *NEVER* aborts, but then that HHH makes a different PROGRAM DDD (which is what Halting is about, PROGRAMS, not non-leaf "C Functions" so your later argument will be also based on lies.

 *In all of the history of the halting problem there*
*have never been a correct return value for this*

Right, there can exist no HHH, that returns the correct answer for the DD built on it.

 typedef void (*ptr)();
int HHH(ptr P);
 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 int main()
{
   HHH(DD);
}
 When we understand that the first point is correct
then we know that HHH returning 0 is correct.
*This has much has never ever been done before*

But your first point is irrelevent, because the only HHH that does correctly emulate its DD, is the one that never returns, so

 Then after we know that HHH(DD) is correct to return
0 for its input we get to applying Mike's idea to
make HHH a pure function.

No, it isn't, because for any HHH that returns 0 for the call HHH(DD) creates a DD that Halts, so it is incorrect.
Your stupid lie of thinking all the DDs are the same is jusdt that, a lie, based on your ignorance of what you are talking about.

 Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/ publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
 

Just lies.

// Entire x86utm operating system that emulates Halt7.obj
https://github.com/plolcott/x86utm
 // source code of termination analyzers and their sample input
https://github.com/plolcott/x86utm/blob/master/Halt7.c
 x86utm.sln   in visual studio
__Run_7.bat  on the command line
 

Which shows that D / DD / DDD will all halt if the function they call returns 0, so that function was NEVER correct to return 0.
All you are doing is promoting the logic of the various logic deniers, because you propose that their broken logic, which is yours, should be considered valid.
Consider yourself partially to blame for the worlds condition.