XPost: comp.theory, sci.logic, comp.lang.c

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.
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.

_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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.lang.c

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.
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.

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.

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

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.

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

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.

_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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

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.
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.

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

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.

But that isn't the required measure, so you are just admitting that your
work is just cheating by using a strawman deception

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

Right, so you are just admitting that you whole work has been based on
cheating by 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.

But the only criteria it is ALLOWED to be measured by is the ACTUAL
criteria, which is based on the actual behavior of the *PROGRAM* the
input represents, which in this case is the DD that calls the HHH that
you claim gives the correct answer.

That program HALTS when run, and thus HHH saying it doesn't is WRONG,
and you are shown to be just a stupid cheater trying to pull a deception
by using the wrong criteria.

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

Right, so you are just admitting that you whole work has been based on
cheating by using the strawman deception

Note, all you have shown is that your logic is based on a total
disreguard for the definitions of the system, and thus is based on LIES
and FALSEHOODS, just like you seem to not think that human laws apply to
you (as shown by your claim that you owning child pornography was "ok"
because the law didn't apply to you since you were "God".

It looks like you will shortly be coming to face with the being that put
into place the actual laws, and you will get to see how little your
ideas of what is right matter compared to what has been DEFINED to be right.

Sorry if that offends you, but that is the facts, you are not God, not
even being the "creator" of the fields you claim to be talking about,
and thus you are subject to the rules of that field.

If you want to play in a different field, you need to find it defined by someone else and follow their rules, or do the work to actually create
it yourself, but it seems you don't know enough to actually do that,
because you just don't understand how logic actually works.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

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.
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.

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.

If you say "Halting Problem" and then aren't actually doing the Halting Problem, then you are just showing that EVERYTHING you have been doing
is based on LIES.


Sorry, but YOU are the one guilty of changing the subject, and perhaps
your lymph node is God pointing out that you are not in control.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 12/8/2024 11:40 AM, olcott wrote:

On 12/7/2024 9: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.
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.

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

test

--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 12/8/2024 12:03 PM, olcott wrote:

On 12/8/2024 11:40 AM, olcott wrote:

On 12/7/2024 9: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.
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.

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

test

--
Copyright 2024 Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)