Discussion:
This first time anyone In the entire history of the halting problem derived a correct return value for HHH(DD)
Add Reply
olcott
2024-12-05 04:20:50 UTC
Reply
Permalink
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.
  >>> 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
 >>> 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
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Chris M. Thomasson
2024-12-05 05:52:49 UTC
Reply
Permalink
Post by olcott
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.
[...]

I hope it's a 100% chance!
Bonita Montero
2024-12-05 17:20:34 UTC
Reply
Permalink
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
olcott
2024-12-07 02:08:26 UTC
Reply
Permalink
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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.

When HHH reports on this behavior of its actual input
it is necessarily correct to reject DD as non halting.
DD emulated by HHH remains stuck in recursive simulation.

Everyone seems to be in universal agreement that HHH
is supposed to report on the behavior of a non-input
except for theory of computation professor Sipser of MIT.

Thus Professor Hehner derived the essence of this halt status criteria:
This algorithm is used by all the simulating termination analyzers:
<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>
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-12-07 02:40:41 UTC
Reply
Permalink
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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?

Note, per the definition of the Halting Problem, which you claim to be
solving, the input shown is not a valid input for a halt decider, as the
input needs to be a FULL PROGRAM, which you are not providing.
Post by olcott
When HHH reports on this behavior of its actual input
it is necessarily correct to reject DD as non halting.
DD emulated by HHH remains stuck in recursive simulation.
But it CAN'T do that, as the
Post by olcott
Everyone seems to be in universal agreement that HHH
is supposed to report on the behavior of a non-input
except for theory of computation professor Sipser of MIT.
Except that the input *IS* the reprentation of the *PROGRAM* DDD, or it
isn't a valid input.

What is "non-input" abot that? If you are excluding the code of HHH from
the input, the input is just invalid and your claims are shown to be
just stupid lies.
No, you are misinterpreting his answer.
Post by olcott
<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>
Right, the decider must determine that a *CORRECT EMULATION* of the
input must not reach a final state, and his definition of a correct
emulation is a emualtion that continues until it reaches a final state,
and thus will be non-halting itself if the program it is emulating is
non-halting.

Note also, D is a PROGRAM, which means it includes ALL its code, which
for your above program includes the code for HHH, so that HHH ever
abortes and return (by incorrectly thinking it has satisfied the first
part) then the actual correct emulation of that input would return, and
H has just failed to meed the requriements of correctly determining that
a correct emulation of the input will never halt.

Your attempt to argue that HHH had to abort is just incorrect, as HHH is
at this point a FIXED program (not your infinite set of deciders) as it
is defined by the code in the input which includes that HHH, and we know
that if HHH acts as you claim, that the correct emulation of the input
will halt, and thus HHH could not have correctly determined that the
emulation of *THIS* input would not halt, so it has just aborted its
emulation in violation of the conditions, and thus has given up the
"protection" of that clause.

Your LYING CHANGING of the input to refer to a different program DDD
that uses a different HHH is just that, A LIE, as that input doesn't
mathc the input that your HHH that answered was given, as it has
different code for the HHH that the DDD called.

Sorry, but all you are doing is proving that you are just an ignorant
liar that doesn't understand the words he is using and apparently
doesn't care that he has no factual basis to make your claims, showing
you are nothing but an ignorant pathological liar.

That WILL be you legacy whenever your cancer takes you unless you repent
and show some ability to learn the actual facts.
olcott
2024-12-07 02:47:54 UTC
Reply
Permalink
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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.

_DD()
[0000213e] 55 push ebp
[0000213f] 8bec mov ebp,esp
[00002141] 51 push ecx
[00002142] 683e210000 push 0000213e
[00002147] e8a2f4ffff call 000015ee ; *call HHH in global memory*
[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]

Line 1354 called on line 1388
https://github.com/plolcott/x86utm/blob/master/Halt7.c
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-12-07 03:50:17 UTC
Reply
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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,

Thus, your entire proof is just a LIE.

If you remove the requirement in your logic of HHH being a global function,
then I have previously shown an HHH that CAN emulate its input to that
final return, and thus refuting your claim.

All you have done is just prove that you are nothing but an ignorant liar
that doesn’t know what his words mean, and who refuse to learn, thus
removing the defense of it just being a honest mistake.

No, you are just showing how utterly STUPID and DISHONEST you have been in
your claims and arguments.

Sorry, but that it just the facts, facts you are just too stupid to
understand.
Post by olcott
_DD()
[0000213e] 55 push ebp
[0000213f] 8bec mov ebp,esp
[00002141] 51 push ecx
[00002142] 683e210000 push 0000213e
[00002147] e8a2f4ffff call 000015ee ; *call HHH in global memory*
[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]
Line 1354 called on line 1388
https://github.com/plolcott/x86utm/blob/master/Halt7.c
olcott
2024-12-07 11:32:08 UTC
Reply
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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.

When the input is allowed to do the opposite of whatever value
that HHH returns this is impossible. The "doing the opposite"
code is unreachable code for DD simulated by any HHH.
Post by Richard Damon
Thus, your entire proof is just a LIE.
When I claim X and you claim not Y THAT IS NOT A REBUTTAL!
I claim that HHH returns the correct answer. You claim that
HHH does not do this in the correct way. Correct way or not
HHH does return the correct answer.

We can apply Mike's convoluted ideas to transform HHH into
returning the correct answer in the correct way.
Post by Richard Damon
If you remove the requirement in your logic of HHH being a global function,
then I have previously shown an HHH that CAN emulate its input to that
final return, and thus refuting your claim.
All you have done is just prove that you are nothing but an ignorant liar
that doesn’t know what his words mean, and who refuse to learn, thus
removing the defense of it just being a honest mistake.
No, you are just showing how utterly STUPID and DISHONEST you have been in
your claims and arguments.
Sorry, but that it just the facts, facts you are just too stupid to
understand.
Post by olcott
_DD()
[0000213e] 55 push ebp
[0000213f] 8bec mov ebp,esp
[00002141] 51 push ecx
[00002142] 683e210000 push 0000213e
[00002147] e8a2f4ffff call 000015ee ; *call HHH in global memory*
[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]
Line 1354 called on line 1388
https://github.com/plolcott/x86utm/blob/master/Halt7.c
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-12-07 12:18:46 UTC
Reply
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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
HHH does correctly reject its input as non-halting.
No, it doesn't do anything "unprecedented".

It si easy to write a function to give the WRONG answer.

After all, once you allow HHH to not be a pure function, I can prove
your claim wrong. (and if you keep you HHH required to be a pure
function, your design just doesn't work). Thus, you are just shown to be
a liar making false claims that have been disproven.

It seems you memory is shot, as you keep on returning to ideas that you
forget have already been disproved.
Post by olcott
When the input is allowed to do the opposite of whatever value
that HHH returns this is impossible. The "doing the opposite"
code is unreachable code for DD simulated by any HHH.
But that is just a meaningless sentence, as partial simulation don't
show "never", just "Not yet"

The problem is you are totally ignorant of the technical meaning of the
words you use, becuase you made yourself intentionally ignorant of the
field, which just proves your basic stupidity
Post by olcott
Post by Richard Damon
Thus, your entire proof is just a LIE.
When I claim X and you claim not Y THAT IS NOT A REBUTTAL!
I claim that HHH returns the correct answer. You claim that
HHH does not do this in the correct way. Correct way or not
HHH does return the correct answer.
When you make a meaningless claim, it means nothing but that you are stupid.

Sorry, but those are the FACTS, which you just continue to prove.
Post by olcott
We can apply Mike's convoluted ideas to transform HHH into
returning the correct answer in the correct way.
Nope. for THIS DD, there is no answer that the HHH that it calls can
return to be correct, as each HHH creates a different input DDD, that
has been constructed to make that HHH wrong.

There IS a correrct answer that HHH SHOULD have returned to be correct,
it just isn't the one that it returns, but other deciders can, and be
right about this input.

Part of your
Post by olcott
Post by Richard Damon
If you remove the requirement in your logic of HHH being a global function,
then I have previously shown an HHH that CAN emulate its input to that
final return, and thus refuting your claim.
All you have done is just prove that you are nothing but an ignorant liar
that doesn’t know what his words mean, and who refuse to learn, thus
removing the defense of it just being a honest mistake.
No, you are just showing how utterly STUPID and DISHONEST you have been in
your claims and arguments.
Sorry, but that it just the facts, facts you are just too stupid to
understand.
Post by olcott
_DD()
[0000213e] 55             push ebp
[0000213f] 8bec           mov ebp,esp
[00002141] 51             push ecx
[00002142] 683e210000     push 0000213e
[00002147] e8a2f4ffff     call 000015ee ; *call HHH in global memory*
[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]
Line 1354 called on line 1388
https://github.com/plolcott/x86utm/blob/master/Halt7.c
olcott
2024-12-07 15:43:26 UTC
Reply
Permalink
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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
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

Try and show any example of any prior work such that
the termination analyzer does return the correct termination
value where the measure of the behavior of DD is DD emulated
by HHH according to the semantics of the x86 language.

Changing the subject to a different criteria
IS CHEATING USING THE STRAWMAN DECEPTION

HHH can also be based on a C language interpreter or a UTM
as long as it gets the same result for the same criteria.

Changing the subject to a different criteria
IS CHEATING USING THE STRAWMAN DECEPTION
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
olcott
2024-12-07 22:46:26 UTC
Reply
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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
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


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.

**according to the semantics of C or x86 machine language.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-12-07 23:35:44 UTC
Reply
Permalink
Post by olcott
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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
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.
Post by olcott
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, and thus
claiming it shows what you claim is just a LIE.
Post by olcott
**according to the semantics of C or x86 machine language.
Nope, because your HHH FAILS to emulate per the x86 machine language,
because aborting a simulation is a violation of those semantics./

Sorry, you are just proving you are nothing but a stupid and ignorant
liar that doesn't care about what is actually true due to your reckless
disregard for the truth.

That is what you are going to leave as your legacy, that you are nothing
but that stupid liar.
olcott
2024-12-07 23:43:27 UTC
Reply
Permalink
Post by Richard Damon
Post by olcott
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Richard Damon
Post by olcott
Post by Bonita Montero
Post by olcott
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.
Maybe you'll solve your halting problem issues before you die.
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
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.
Post by olcott
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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
olcott
2024-12-07 22:09:36 UTC
Reply
Permalink
...
Can I suggest you consider trimming news groups? No one can stop PO
spraying nonsense all over Usenet, but the damage can be limited by
thoughtful replies.
I may not be alive very much longer so this is my
last ditch effort. A lymph node next to my heart
has doubled in volume every 18.66 days for 68 days
so far. That is a 3.815% daily increase.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
olcott
2024-12-08 19:34:19 UTC
Reply
Permalink
Post by olcott
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.
  >>> 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
 >>> 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
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.
Post by olcott
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.

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.
Post by olcott
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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-12-08 20:36:49 UTC
Reply
Permalink
Post by olcott
Post by olcott
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.
  >>> 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
 >>> 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
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.
Post by olcott
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.
Post by olcott
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.
Post by olcott
Post by olcott
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.
olcott
2024-12-09 01:41:39 UTC
Reply
Permalink
Post by Richard Damon
Post by olcott
Post by olcott
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.
  >>> 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
 >>> 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
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.
Post by olcott
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]
Post by Richard Damon
Post by olcott
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.
Post by olcott
Post by olcott
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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
olcott
2024-12-09 04:15:42 UTC
Reply
Permalink
Post by olcott
Post by Richard Damon
Post by olcott
Post by olcott
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.
  >>> 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
 >>> 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
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.
Post by olcott
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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
olcott
2024-12-11 04:52:07 UTC
Reply
Permalink
Post by olcott
Post by olcott
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.
  >>> 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
 >>> 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
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.
Post by olcott
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.
Post by olcott
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.
Nope, sincr the program DD will halt and the program HHH says it will not.
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);
}

You may be indoctrinated against these essential truths
yet they remain true just the same.

(1) Halt Deciders / Termination analyzers compute the
mapping from their input finite string to the actual
behavior that it specifies. NON-INPUTS ARE NOT ALLOWED.

(2) DD simulated/emulated by any HHH according to the
semantics of the C/x86 language cannot possibly reach
it own final halt state.

Your tactic of "rebutting" these truths is to change the
subject entirely. You never assess the exact words that
I actually said.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Richard Damon
2024-12-11 11:56:37 UTC
Reply
Permalink
Post by olcott
Post by olcott
Post by olcott
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.
  >>> 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
 >>> 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
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.
Post by olcott
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.
Post by olcott
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.
Nope, sincr the program DD will halt and the program HHH says it will not.
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);
}
You may be indoctrinated against these essential truths
yet they remain true just the same.
(1) Halt Deciders / Termination analyzers compute the
mapping from their input finite string to the actual
behavior that it specifies. NON-INPUTS ARE NOT ALLOWED.
And the Actual Behavior that it specifies s *DEFINED* as the behavior of
running the *PROGRAM* that the input describes.

Note, *PROGRAM*, so the input *MUST* describe a FULL program, meaning
*ALL* the code, so for DD *MUST* include the code for the HHH that it calls.

Thus, and "finite string" input that doesn't, just isn't a valid input.

That is like asking for the sum of 1 and?


Tou are just showing you don't undetstand the meaning of the fundamental
term "program" or "input"
Post by olcott
(2) DD simulated/emulated by any HHH according to the
semantics of the C/x86 language cannot possibly reach
it own final halt state.
But "behavior" is defined by the direct running, or the FULL
simulation/emulation of that input, which needs to be a full program,
*NOT* just a partial emulation.

Since the HHH that DD calls *DOES* abort (as you say it does), that
means HHH's emulation is *NOT* what defines the "behavior" of the input.

The behavior of the above input, when we include the needed code for
HHH, shows that DD will halt, as that is what DD does when run, since
you have specified that your final HHH will return 0, since you claim it
is correct to do so, so thus you are asserting that is its behavior, or
you are just stupid liar,
Post by olcott
Your tactic of "rebutting" these truths is to change the
subject entirely. You never assess the exact words that
I actually said.
No, you "tactic" of using incorrect definitions just proves you are
nothing but a stupid liar.

The problem is your "exact words" are just non-sense lies based on
incorrect definitions.


Sorry, but you are just proving your stupidity, and the fact that you
just keep repeating your incorrect statements and never even try to
answer the errors pointed out show that either you know you are wrong,
or are too stupid to understand what you are talking about, or more
likely both, ie you know your statements are wrong, but want to beleive
them, and are too stupid to understand that wrong is wrong.

This is going to be your final reputation, that Peter Olcott never
understood the basics of the logic he was trying to use, but kept
himself in his imaginary, and self-contradictory world.

Loading...