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);
}
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*
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.
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
// 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
On 12/7/2024 5:35 PM, Richard Damon wrote:
On 12/7/24 5:46 PM, olcott wrote:
On 12/7/2024 4:20 PM, Richard Damon wrote:
On 12/7/24 1:44 PM, olcott wrote:
On 12/7/2024 12:07 PM, Richard Damon wrote:
On 12/7/24 10:43 AM, olcott wrote:
On 12/7/2024 6:18 AM, Richard Damon wrote:
On 12/7/24 6:32 AM, olcott wrote:
On 12/6/2024 9:50 PM, Richard Damon wrote:
olcott <polcott333@gmail.com> wrote:
On 12/6/2024 8:40 PM, Richard Damon wrote:
On 12/6/24 9:08 PM, olcott wrote:
On 12/5/2024 11:20 AM, Bonita Montero wrote:
Am 05.12.2024 um 05:20 schrieb olcott:
There is an 80% chance that I will be alive in one month. >>>>>>>>>>>>>>> There may be an extended pause in my comments.Maybe you'll solve your halting problem issues before you >>>>>>>>>>>>>> die.
I will try to bring a computer to the out of town hospital. >>>>>>>>>>>>>>
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);
}
I am sure that DD correctly emulated by HHH according to >>>>>>>>>>>>> the semantics of the C programming language cannot possibly >>>>>>>>>>>>> reach its own return instruction final halt state.
How does HHH correctly emulated DD, if it isn't give tne >>>>>>>>>>>> code for the
HHH that DD calls?
As I have told you many dozens of times HHH and DD share >>>>>>>>>>> the same global memory space within memory version of the >>>>>>>>>>> Halt7.obj file.
And thus you admit that your HHH isn’t the required “pure >>>>>>>>>> function” as its
result is dependent on that contents of that global memory, >>>>>>>>>> and not just
its input, as required by the definition of a global function, >>>>>>>>>>
First we have to acknowledge that pure function or not HHH does >>>>>>>>> something unprecedented in the history of the halting problem: >>>>>>>>> HHH does correctly reject its input as non-halting.
No, it doesn't do anything "unprecedented".
Changing the subject to a different criteria
IS CHEATING USING THE STRAWMAN DECEPTION
Right, which is what *YOU* have done. As your subject says, you
are talking about the *HALTING PROPBLEM* which has a defined
criteeria
When I say the the work that I accomplished ON MY CRITERIA
has never been done before IT IS WOEFULLY DISHONEST to
rebut this by changing the subject to some other criteria.
Then the work you have accopmllished is just a LIE.
Just like the climare and election deniers.
I wrote a paper on climate change
Severe anthropogenic climate change proven entirely with verifiable
facts
https://www.researchgate.net/
publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts
So? Your claim you get to redefine the terms of the problem allow the
deniers to do the same.
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 I say that simulating termination analyzer HHH does
correctly reject DD on the basis that DD emulated by HHH**
does not halt THIS IS A MATTER OF FACT.
But is irrelevent for the problem you claim to be working on,
First you must understand it is true otherwise we cannot
proceed to the next step of relevance.
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);
}
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*
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.
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:DDD emulated by any HHH according to the semantics of
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote:I did not mention anything about answers my entire
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:We know that HHH halts. It doesn't simulate itself halting. >>>>>>>>>>>>>>>>
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE >>>>>>>>>>>>>>>>> ITSELF.
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. >>>>>>>>>>>>>
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", >>>>>>>>>>>
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.
_DD()
[0000213e] 55 push ebp // house keeping [0000213f] 8bec mov ebp,esp // house keeping [00002141] 51 push ecx // house keeping [00002142] 683e210000 push 0000213e // push address of DD
[00002147] e8a2f4ffff call 000015ee // call HHH in same memory space [0000214c] 83c404 add esp,+04
[0000214f] 8945fc mov [ebp-04],eax
[00002152] 837dfc00 cmp dword [ebp-04],+00
[00002156] 7402 jz 0000215a
[00002158] ebfe jmp 00002158
[0000215a] 8b45fc mov eax,[ebp-04]
[0000215d] 8be5 mov esp,ebp
[0000215f] 5d pop ebp
[00002160] c3 ret
Size in bytes:(0035) [00002160]
void DDD()
{
HHH(DDD);
return;
}
The behavior of DDD simulated by HHH is isomorphic.
I provide this example for people that are only novices
with C programming.
Only in the sense that by your definitions, neither is possible beyond
the first 4 instruciton, as the code for HHH has been excluded from
the input.
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.
We know otherwise.
Sorry, you are just proving that your "arguement" is just based on
lies and bad defintions, which shows your utter stupidity and lack of
respect for what is true.
That is your legacy, that Peter Olcott had no idea about what he was
talking about and just live a life based on lying.
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: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.
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote: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.
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:We know that HHH halts. It doesn't simulate itself >>>>>>>>>>>>>>>>>> halting.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE >>>>>>>>>>>>>>>>>>> ITSELF.
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. >>>>>>>>>>>>>>>
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", >>>>>>>>>>>>>
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.
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:It proves that HHH does emulate itself emulating DDD.
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:DDD emulated by any HHH according to the semantics of
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", >>>>>>>>>
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 >>>
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.
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: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.
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:We know that HHH halts. It doesn't simulate itself >>>>>>>>>>>>>>>>>>>> halting.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE >>>>>>>>>>>>>>>>>>>>> ITSELF.
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. >>>>>>>>>>>>>>>>>
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.
On 12/9/2024 4:54 AM, Mikko wrote:
On 2024-12-08 19:34:19 +0000, olcott said:
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:DDD emulated by any HHH according to the semantics of
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote:I did not mention anything about answers my entire
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:We know that HHH halts. It doesn't simulate itself halting. >>>>>>>>>>>>>>>>
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE >>>>>>>>>>>>>>>>> ITSELF.
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. >>>>>>>>>>>>>
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", >>>>>>>>>>>
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.
No, they not. They have agreed that DD returns only if HHH returns
0 and that HHH is not able to simulated DD to that point.
Everyone disagreeing with this has dishonestly used to strawman
deception to refer to different behavior than DD simulated by HHH.
The topic as specified on the subject line is the behaviour of DD and
what HHH should report. Simulation is not mentioned there.
I can't put more than a sentence on the subject line.
The context of everything that I have ever be talking about
has ALWAYS included simulation/emulation.
HHH does correctly reject DD as non halting even if it
does not do this in the correct way.
No one has ever done this before. Prior to my work no
correct return value existed because DD did the opposite of
whatever value that HHH returned. When DD is simulated/emulated
by HHH the code that "does the opposite" is unreachable.
On 12/9/2024 4:54 AM, Mikko wrote:
On 2024-12-08 19:34:19 +0000, olcott said:
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:DDD emulated by any HHH according to the semantics of
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote:I did not mention anything about answers my entire
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. >>>>>>>>>>>>>
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", >>>>>>>>>>>
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.
No, they not. They have agreed that DD returns only if HHH returns
0 and that HHH is not able to simulated DD to that point.
Everyone disagreeing with this has dishonestly used to strawman
deception to refer to different behavior than DD simulated by HHH.
The topic as specified on the subject line is the behaviour of DD and
what HHH should report. Simulation is not mentioned there.
I can't put more than a sentence on the subject line.
On 12/10/2024 1:35 AM, Mikko wrote:
On 2024-12-09 13:46:16 +0000, olcott said:
On 12/9/2024 4:54 AM, Mikko wrote:
On 2024-12-08 19:34:19 +0000, olcott said:
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: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.
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote: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.
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:We know that HHH halts. It doesn't simulate itself >>>>>>>>>>>>>>>>>> halting.
>>> HHH can't simulate itself.
That is WRONG !!!
HHH DOES EMULATE ITSELF PROVING THAT IT CAN EMULATE >>>>>>>>>>>>>>>>>>> ITSELF.
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. >>>>>>>>>>>>>>>
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", >>>>>>>>>>>>>
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.
No, they not. They have agreed that DD returns only if HHH returns
0 and that HHH is not able to simulated DD to that point.
Everyone disagreeing with this has dishonestly used to strawman
deception to refer to different behavior than DD simulated by HHH.
The topic as specified on the subject line is the behaviour of DD and
what HHH should report. Simulation is not mentioned there.
I can't put more than a sentence on the subject line.
What you did put there specifies that the halting problem is on topic
and therefore is not "strawman".
In the specific aspect of the "do the opposite of whatever HHH says"
halting problem input DD, HHH does correctly reject DD as non-halting
on the basis that DD emulated by any HHH cannot possibly reach its
own final state.
Whether or not HHH did this the proper way is a different
subject. We only examining the single aspect of the correctness
of the return value. We are not examining any other aspect.
This one single aspect seems to be unprecedented progress.
On 12/10/2024 1:35 AM, Mikko wrote:
On 2024-12-09 13:46:16 +0000, olcott said:
On 12/9/2024 4:54 AM, Mikko wrote:
On 2024-12-08 19:34:19 +0000, olcott said:
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: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. >>>>>>>>>>>>>
On 12/3/2024 5:39 PM, Richard Damon wrote:
On 12/3/24 6:08 PM, olcott wrote: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.
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. >>>>>>>>>>>>>>>
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", >>>>>>>>>>>>>
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.
No, they not. They have agreed that DD returns only if HHH returns
0 and that HHH is not able to simulated DD to that point.
Everyone disagreeing with this has dishonestly used to strawman
deception to refer to different behavior than DD simulated by HHH.
The topic as specified on the subject line is the behaviour of DD and
what HHH should report. Simulation is not mentioned there.
I can't put more than a sentence on the subject line.
What you did put there specifies that the halting problem is on topic
and therefore is not "strawman".
In the specific aspect of the "do the opposite of whatever HHH says"
halting problem input DD, HHH does correctly reject DD as non-halting
on the basis that DD emulated by any HHH cannot possibly reach its
own final state.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 156:45:18 |
| Calls: | 10,384 |
| Calls today: | 1 |
| Files: | 14,056 |
| Messages: | 6,416,471 |