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

On 12/8/24 11:43 PM, olcott wrote:

On 12/8/2024 10:29 PM, Richard Damon wrote:

olcott <polcott333@gmail.com> wrote:

On 12/8/2024 7:57 PM, Richard Damon wrote:

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

On 12/8/2024 2:36 PM, Richard Damon wrote:

On 12/8/24 2:34 PM, olcott wrote:

On 12/8/2024 4:55 AM, Mikko wrote:

On 2024-12-05 04:20:50 +0000, olcott said:
>

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.
>
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.
>
Once we get through this point then we know that DDD
does not halt:
>
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*
>
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.
>
*In all of the history of the halting problem there*
*have never been a correct return value for this*
>
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);
}

>
This is not a useful main. It is sufficient to determine whether HHH
returns but not to determine whther it returns the correct value.
>

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*

>
This is one of the well known methods to prove that the value HHH
returns
is incorrect. If HHH returns 0 then DD returns 0 but the meaning of
0 in
this context is that DD does not halt. THerefore the value returned by
HHH is incorrect.
>

>
Every expert in the C programming language has agreed that DD
simulated by HHH cannot possibly return. Everyone disagreeing
with this has dishonestly used to strawman deception to refer to
different behavior than DD simulated by HHH.
>

>
Whch is just irrelevent, as the halting question isn't about DD
partially emulated by the decider, but about the ACTUAL behavior of
the program, or its COMPLETE emulation, of the COMPLETE program the
input represent, which INCLUDES the code of the HHH that it calls.
>
And, by your definition of what you can "the input" which excludes
the explicit mentioning of the code of HHH, we can't even do that, as
your input isn't that of a program, but just an unrunable program
fragment.
>

>
Your ADD may make it impossible for you to pay enough attention.

>
And your stupidity make it impossible for you to understand what you are
talking about.
>
It is IMPOSSIBLE to "define" the behavior of the following strictly by
the behavior of the x86 machine language, as that doesn't specify what
the HHH that DD calls will do.
>

>
Maybe I simply did not explain it well enough.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
>
The above file is translated into Halt7.obj that the
x86utm operating system emulates in the same memory
space. DD simply calls HHH in its own memory space.
The machine code itself is always in the same global
memory space.
>

>
So, what is defined to be the “input” of HHH?
>
If it is just the object code of DD / DDD, then HHH just can’t emulate that
without being a non-pure function, and without the requirement to be a pure
function, I have shown an HHH that meets your requirement to emulate to the
end, and thus your claim is false.
>

 Yes it seems to be your ADD. Halt7.obj is in a single
global space. Let's see if you can understand that one
point before moving on.
 I know that you probably know what a single global memory
space is. It seems that you just can't manage to remember
that Halt7.obj is in a single global memory space.
 

So, you ADMIT that you claims about HHH are just lies.
Clearly, if HHH can examine the global memory space, and not just the "input" given to it, then HHH can begin something like:
int flag = 0;
int HHH(ptr  P) {
   if (flag) return 0;
   flag = 1;
then the rest of your current HHH, with the abort disabled (or just use your non-aborting version you hypothocate.)
Such an HHH *CAN* emulate the input to its final state, as that input will end up just calling HHH, test the flag, which at that point will be 1, and then return.
Sorry, you are just proving that you are totally ignorant of what you are talking about, and have a reckless disregard for the truth, making you nothing but a pathetic pathological liar.
It seems you are incapable of answering the question put to you, either due to total ignorance, or the fact that you know that answering them will prove you wrong.
You have already demonstrated that you are nothing but a liar by the fact that you contradict previous claims and act like you never said them when you find they get you into untenable positions, so you just just out of the frying pan into the fire.
My expectation is that you will shortly find your self forever in such a fire, and asking yourself why you found it impossible to halt your lies.