From Newsgroup: comp.theory

*The best selling author of theory of computation textbooks*
<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>

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

I made D simpler so that the key essence of recursive simulation
could be analyzed separately. ChatGPT totally understood this.

void DDD()
{
HHH(DDD);
return;
}

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

On 11/3/2024 12:20 PM, Richard Damon wrote:

On 11/3/24 9:39 AM, olcott wrote:

The finite string input to HHH specifies that HHH
MUST EMULATE ITSELF emulating DDD.

Right, and it must CORRECTLY determine what an unbounded
emulation of that input would do, even if its own programming
only lets it emulate a part of that.

*Breaking that down into its key element*

[This bounded HHH] must CORRECTLY determine what
an unbounded emulation of that input would do...

When that input is unbounded that means it is never
aborted at any level, otherwise it is bounded at some
level thus not unbounded.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 2:28 PM, olcott wrote:

*The best selling author of theory of computation textbooks*
<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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

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>

Which your H doesn't do.

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

And also means that it can not be aborted, as "stopping" in the middle
is not to the semantics of the x86 language.

An thus, your H fails to determine that the CORRECT emulation by H will
not terminate, since it doesn't do one.

I made D simpler so that the key essence of recursive simulation
could be analyzed separately. ChatGPT totally understood this.

Nope, your broke the rules of the field, and thus invalidates your proof.

Either by passing the address of DDD to HHH implies passing the FULL
MEMORY that DDD is in (or at least every part accessed in the emulation
of DDD) and thus changed in your

void DDD()
{
HHH(DDD);
return;
}

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

But DDD doesn't call an "ideaized" verision of HHH, it calls the exact function defined as HHH, s0 your arguemet is based on false premises,
and thus is just a :OE/

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

On 11/3/2024 12:20 PM, Richard Damon wrote:

On 11/3/24 9:39 AM, olcott wrote:

The finite string input to HHH specifies that HHH
MUST EMULATE ITSELF emulating DDD.

Right, and it must CORRECTLY determine what an unbounded
emulation of that input would do, even if its own programming
only lets it emulate a part of that.

*Breaking that down into its key element*

[This bounded HHH] must CORRECTLY determine what
an unbounded emulation of that input would do...

When that input is unbounded that means it is never
aborted at any level, otherwise it is bounded at some
level thus not unbounded.

No, because there aren't "levels" of emulation under consideration here.
Only does the emulation that the top level HHH is doing, since
everything else is just fixed by the problem.


I guess you are just doubling down on your committement to prove that
you are nothing but an pathetic pathological lying idiot that doesn't understand a thing that he is talking about.


--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

*The best selling author of theory of computation textbooks*
<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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

That is what I have been saying for years.
(even though there cannot be such a thing
as the complete emulation of a non-terminating input).

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its
emulation and it does reject its input D as non-halting.
I just ran the code and it does do this. https://github.com/plolcott/x86utm/blob/master/Halt7.c

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

And also means that it can not be aborted, as "stopping" in the middle
is not to the semantics of the x86 language.

Every H, HH, HHH, H1, HH1, and HHH1
(a) Predicts that its input would not stop running unless aborted.
(b) Lets its input continue to run until completion.

An thus, your H fails to determine that the CORRECT emulation by H will
not terminate, since it doesn't do one.

I made D simpler so that the key essence of recursive simulation
could be analyzed separately. ChatGPT totally understood this.

Nope, your broke the rules of the field, and thus invalidates your proof.

Either by passing the address of DDD to HHH implies passing the FULL
MEMORY that DDD is in (or at least every part accessed in the emulation
of DDD) and thus changed in your

void DDD()
{
HHH(DDD);
return;
}

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the
recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

But DDD doesn't call an "ideaized" verision of HHH,

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

*simulated D would never stop running unless aborted*
has ALWAYS been this idealized input.

it calls the exact
function defined as HHH, s0 your arguemet is based on false premises,
and thus is just a :OE/

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

On 11/3/2024 12:20 PM, Richard Damon wrote:

On 11/3/24 9:39 AM, olcott wrote:

;
The finite string input to HHH specifies that HHH
MUST EMULATE ITSELF emulating DDD.

;
Right, and it must CORRECTLY determine what an unbounded
emulation of that input would do, even if its own programming
only lets it emulate a part of that.
;

*Breaking that down into its key element*

[This bounded HHH] must CORRECTLY determine what
an unbounded emulation of that input would do...

When that input is unbounded that means it is never
aborted at any level, otherwise it is bounded at some
level thus not unbounded.

No, because there aren't "levels" of emulation under consideration here.

There sure the Hell are.
*simulated D would never stop running unless aborted*
*simulated D would never stop running unless aborted*
*simulated D would never stop running unless aborted*
Has always involved levels of simulation when
H emulates itself emulating D

Only does the emulation that the top level HHH is doing, since
everything else is just fixed by the problem.

*simulated D would never stop running unless aborted*
*simulated D would never stop running unless aborted*
*simulated D would never stop running unless aborted*
has always meant reject D
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and it does reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway.
This H is the same as that one. They are the same. There is only one.
If not, H is not simulating the counterexample that calls H.

Correct simulation is defined as D is emulated by H according to the
semantics of the x86 language thus includes H emulating itself
emulating D.

And also means that it can not be aborted, as "stopping" in the middle
is not to the semantics of the x86 language.

Every H, HH, HHH, H1, HH1, and HHH1 (a) Predicts that its input would
not stop running unless aborted.
(b) Lets its input continue to run until completion.

No, it aborts.

But DDD doesn't call an "ideaized" version of HHH,

*simulated D would never stop running unless aborted*
has ALWAYS been this idealized input.

Ah no, that is not the counterexample. No disagreement with that.
We are not talking about the "idealised" version, but about
the actual, literal description of D, which calls H, which DOES
IN FACT abort.

*Breaking that down into its key element*

[This bounded HHH] must CORRECTLY determine what an unbounded
emulation of that input would do...

Problem is, the input under scrutiny changes along with HHH.

When that input is unbounded that means it is never aborted at any
level, otherwise it is bounded at some level thus not unbounded.

No, because there aren't "levels" of emulation under consideration
here.

*simulated D would never stop running unless aborted*
Has always involved levels of simulation when H emulates itself
emulating D

Apparently D doesn’t call (or H doesn’t simulate) H, which aborts,
but rather H1, which doesn’t. The interesting case is H simulating
the actual input, which includes simulating the same abort check
itself is using.
--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 4:45 PM, olcott wrote:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

*The best selling author of theory of computation textbooks*
<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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

That is what I have been saying for years.
(even though there cannot be such a thing
as the complete emulation of a non-terminating input).

So, you just agreed that the correct answer for HHH, is based on the
behavior of the COMPLETE emulation of the EXACT input that HHH got.

Since that is DDD that calls the HHH that aborts and returns 0, and that
is exactly the emulation that HHH1 does, and reaches its end, shows that
the correct answer for HHH is to say HALTING, and thus it is wrong.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its
emulation and it does reject its input D as non-halting.
I just ran the code and it does do this. https://github.com/plolcott/x86utm/blob/master/Halt7.c

Yes, H rejects its input CLAIMING it to be non-halting, but didn't do a complete emulation of that input, so by itself it doesn't actually
establish it to be correct.

H1, when given that exact same input, the D that calls H, DOES doe a
complete emulation of that exact input, and it reaches the end, thus
PROVING that D is a HALTING computation, and H was just wrong.

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

And also means that it can not be aborted, as "stopping" in the middle
is not to the semantics of the x86 language.

Every H, HH, HHH, H1, HH1, and HHH1
(a) Predicts that its input would not stop running unless aborted.
(b) Lets its input continue to run until completion.

No, H1, HH1, and HHH1, see that the input to H, HH, and HHH
respectfully, (which is the D that calls H, the DD that calls HH, and
the DDD that calls HHH, in each case the one that aborted and returns 0)
can be emuiated by itself to the end, thus showing the input is Halting,
and thus PROVING that H, HH, and HHH were incorrect to say the input is non-halting.

An thus, your H fails to determine that the CORRECT emulation by H
will not terminate, since it doesn't do one.

I made D simpler so that the key essence of recursive simulation
could be analyzed separately. ChatGPT totally understood this.

Nope, your broke the rules of the field, and thus invalidates your proof.

Either by passing the address of DDD to HHH implies passing the FULL
MEMORY that DDD is in (or at least every part accessed in the
emulation of DDD) and thus changed in your

void DDD()
{
HHH(DDD);
return;
}

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the
recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

But DDD doesn't call an "ideaized" verision of HHH,

    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

    *simulated D would never stop running unless aborted*
    has ALWAYS been this idealized input.

Nope, there is no such thing in Comptation Theory, a machine is only and exactly the machine that it is.

Sorry, you just admitted that you don't know what you are talking about.

it calls the exact function defined as HHH, s0 your arguemet is based
on false premises, and thus is just a :OE/

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

On 11/3/2024 12:20 PM, Richard Damon wrote:

On 11/3/24 9:39 AM, olcott wrote:

;
The finite string input to HHH specifies that HHH
MUST EMULATE ITSELF emulating DDD.

;
Right, and it must CORRECTLY determine what an unbounded
emulation of that input would do, even if its own programming
only lets it emulate a part of that.
;

*Breaking that down into its key element*

[This bounded HHH] must CORRECTLY determine what
an unbounded emulation of that input would do...

When that input is unbounded that means it is never
aborted at any level, otherwise it is bounded at some
level thus not unbounded.

No, because there aren't "levels" of emulation under consideration here.

There sure the Hell are.
    *simulated D would never stop running unless aborted*
    *simulated D would never stop running unless aborted*
    *simulated D would never stop running unless aborted*
Has always involved levels of simulation when
H emulates itself emulating D

But the outer emulator doesn't care about the other levels of emulation,
and since D calls an H that will abort its emulation, that emulation
doesn't go on forever.

Only does the emulation that the top level HHH is doing, since
everything else is just fixed by the problem.

    *simulated D would never stop running unless aborted*
    *simulated D would never stop running unless aborted*
    *simulated D would never stop running unless aborted*
has always meant reject D

But THAT D, that calls an H that aborts its input, can be simulated
without needing to be aborted.

Since that *IS* the D that H was given (if it is a H that aborts its
input, and if not it fails by not answering) so we see that the
emulation of the outer H will halt even if not aborted, but that H can't
do that emulation since it is programmed to abort, and a machine like it
that doesn't abort isn't it.

Your logic is just based on the LIE that programs can be changes.

Sorry, you are just proving how STUPID and IGNORANT you are of what you
are talking about.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

That is what I have been saying for years.

If.

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> >>>> Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the
problem, it admits that your criteria for HHH is incorrect, and DDD does
halt and HHH should have reported Halting.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter what emulator looks at it.

Some may only be able to give partial emulation.

You are shown you don't actually beleive your claim, as you have failed
to even TRY to refute the argument that they are the same, as you can't
show what the first instruction that was actually correctly emulated
differed in behavior.

If no instruction showed a different behavior, you can't claim them to
be different.

Calling too things that are the same as different is just a lie.

And saying a partial trace that exactly matches the complete trace shows evidence that it will be different is also just a lie.

Sorry, but that IS the facts, even if you don't like them, don't believe
them, or can't understand them.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and it does >>>> reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the
problem, it admits that your criteria for HHH is incorrect, and DDD does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the
recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise >>>>>> input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and it
does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the
problem, it admits that your criteria for HHH is incorrect, and DDD
does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the
recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter what
emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet the requirements for a property to be decided by a decider.

So, YOU are the one that has already proven you have maximum stupidity.

Sorry, but until you actually define "Olcotts Theory of Computaiton"
based on "Olcotts Theory of Correct Reasoning" in a full and complete
manner, you are just stuck arguing by the "received" rules you dislike.

If you won't play by the rules, the game just kicks you out, and to
continue to claim to be in the game is juat a LIE.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/2024 7:20 PM, Richard Damon wrote:

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise >>>>>>> input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and it >>>>>> does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway. >>>>

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the
problem, it admits that your criteria for HHH is incorrect, and DDD
does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the >>>> recursion. In the simulation, DDD() is seen as endlessly recursive, so >>>> HHH concludes that it would not halt without external intervention.

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong.

DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter
what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet the requirements for a property to be decided by a decider.

That you think that you can get away with disagreeing with the
semantics of the x86 language for termination analyzer HHH
seems a little too stupid, thus we seem to be only left with
dishonestly.

The semantics of the x86 language proves that HHH emulates itself
emulating DDD and HHH1 does not emulate itself emulating DDD.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 9:14 PM, olcott wrote:

On 11/10/2024 7:20 PM, Richard Damon wrote:

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this precise >>>>>>>> input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and >>>>>>> it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts anyway. >>>>>

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the
problem, it admits that your criteria for HHH is incorrect, and DDD
does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the >>>>> recursion. In the simulation, DDD() is seen as endlessly recursive, so >>>>> HHH concludes that it would not halt without external intervention.

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong. >>>>>
DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter
what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet the
requirements for a property to be decided by a decider.

That you think that you can get away with disagreeing with the
semantics of the x86 language for termination analyzer HHH
seems a little too stupid, thus we seem to be only left with
dishonestly.

WHERE did I disagree with the semantics of the x86 language?

You are just up to your old lies again.

The best judge of the x86 language is running the program described by
the input on a real CPU.

DDD() halts, so NOTHING in the x86 semantics can say otherwise, just
your LIES where you don't undetstand how computers actually work.

The semantics of the x86 language proves that HHH emulates itself
emulating DDD and HHH1 does not emulate itself emulating DDD.

Nope, but your baseless claims where you try to invoke something like
that just proves you are a pathological liar.

You wouldn't know what truth was if it was taking a bite out of your nose.


--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/2024 9:09 PM, Richard Damon wrote:

On 11/10/24 9:14 PM, olcott wrote:

On 11/10/2024 7:20 PM, Richard Damon wrote:

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this >>>>>>>>> precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and >>>>>>>> it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts
anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the
problem, it admits that your criteria for HHH is incorrect, and DDD >>>>> does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops >>>>>> the
recursion. In the simulation, DDD() is seen as endlessly
recursive, so
HHH concludes that it would not halt without external intervention. >>>>>

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong. >>>>>>
DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter
what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet the
requirements for a property to be decided by a decider.

That you think that you can get away with disagreeing with the
semantics of the x86 language for termination analyzer HHH
seems a little too stupid, thus we seem to be only left with
dishonestly.

WHERE did I disagree with the semantics of the x86 language?

You are just up to your old lies again.

The best judge of the x86 language is running the program described by
the input on a real CPU.

DDD() halts, so NOTHING in the x86 semantics can say otherwise, just
your LIES where you don't undetstand how computers actually work.

Saying that DDD() halts when you know damn well that
DDD emulated by HHH does not halt is a damned lie that
could get you condemned to actual Hell.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 10:18 PM, olcott wrote:

On 11/10/2024 9:09 PM, Richard Damon wrote:

On 11/10/24 9:14 PM, olcott wrote:

On 11/10/2024 7:20 PM, Richard Damon wrote:

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this >>>>>>>>>> precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation and >>>>>>>>> it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts >>>>>>>> anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of the >>>>>> problem, it admits that your criteria for HHH is incorrect, and
DDD does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution >>>>>>> to stop DDD() from running forever. But when HHH simulates DDD(), >>>>>>> it's analyzing an "idealized" version of DDD() where nothing
stops the
recursion. In the simulation, DDD() is seen as endlessly
recursive, so
HHH concludes that it would not halt without external intervention. >>>>>>

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2
This link is live so you can try to convince ChatGPT that its wrong. >>>>>>>
DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter >>>>>> what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet the
requirements for a property to be decided by a decider.

That you think that you can get away with disagreeing with the
semantics of the x86 language for termination analyzer HHH
seems a little too stupid, thus we seem to be only left with
dishonestly.

WHERE did I disagree with the semantics of the x86 language?

You are just up to your old lies again.

The best judge of the x86 language is running the program described by
the input on a real CPU.

DDD() halts, so NOTHING in the x86 semantics can say otherwise, just
your LIES where you don't undetstand how computers actually work.

Saying that DDD() halts when you know damn well that
DDD emulated by HHH does not halt is a damned lie that
could get you condemned to actual Hell.

But DDD emulated by HHH doesn't say what the correct emulation per the
x86 language defines, since your HHH doesn't do a correct emulation
since it aborts its emulation, which isn't according to the semantics of
the x86 language, so you statement is just a lying strawman.

Sorry, making false claims like you do just proves that you are nothing
but an ignorant pathological lying idiot.

IF you can show a reliable reference that says that a correct smeantics
of a program can be defined by only a partial emulation of it, go ahead. (Note, not that some program might be able to compute the answer with a partial emulatio, but that the results of the partial emulation DEFINES
what the answer is).

If you can show a reliable reference that says that the correct
determinati0n for a halting problem is correctly based on your criteria,
go ahead an provide it.

Your problem is you don't actually know the rules, but have made them up
based on your imperfect analysis of the field, and then you lie and
claim to be an expert.

You are just proving that nobody should ever trust anything you say,
because you are nothing but an ignorant pathetic pathological lying
idiot, that has no idea of the meaning of the words he is using, and no respect for the truth.

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/2024 9:55 PM, Richard Damon wrote:

On 11/10/24 10:18 PM, olcott wrote:

On 11/10/2024 9:09 PM, Richard Damon wrote:

On 11/10/24 9:14 PM, olcott wrote:

On 11/10/2024 7:20 PM, Richard Damon wrote:

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this >>>>>>>>>>> precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation >>>>>>>>>> and it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts >>>>>>>>> anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of
the problem, it admits that your criteria for HHH is incorrect, >>>>>>> and DDD does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution >>>>>>>> to stop DDD() from running forever. But when HHH simulates DDD(), >>>>>>>> it's analyzing an "idealized" version of DDD() where nothing
stops the
recursion. In the simulation, DDD() is seen as endlessly
recursive, so
HHH concludes that it would not halt without external intervention. >>>>>>>

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2 >>>>>>>> This link is live so you can try to convince ChatGPT that its >>>>>>>> wrong.

DDD emulated by HHH has different behavior than DDD emulated
by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no matter >>>>>>> what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet the >>>>> requirements for a property to be decided by a decider.

That you think that you can get away with disagreeing with the
semantics of the x86 language for termination analyzer HHH
seems a little too stupid, thus we seem to be only left with
dishonestly.

WHERE did I disagree with the semantics of the x86 language?

You are just up to your old lies again.

The best judge of the x86 language is running the program described
by the input on a real CPU.

DDD() halts, so NOTHING in the x86 semantics can say otherwise, just
your LIES where you don't undetstand how computers actually work.

Saying that DDD() halts when you know damn well that
DDD emulated by HHH does not halt is a damned lie that
could get you condemned to actual Hell.

But DDD emulated by HHH doesn't say what the correct emulation per the
x86 language defines,

Yes it is and you are a liar for saying otherwise. Unless
you repent you many be a literally (condemned to actual Hell)
damned liar.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 2024-11-10 19:28:28 +0000, olcott said:

*The best selling author of theory of computation textbooks*
<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>

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

No, that definition does not apply to Sipser's words. There a "correct simulation" measn a simulation that Sipser regards as correct, which
probably is the same as what "coreect simulation" means in Common
Language.
--
Mikko

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

OP says nothing aobut how emulationg termination analyzers are supposed to work. I think that is OK. Philosophers may have opinions about that but
the question is not really relevant for theorieticsl or practical purposes.

Anyone who wants to present or sell an emulating termination analyzer should tell what that particular analyzer actually does.
--
Mikko

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On Mon, 2024-11-11 at 13:33 +0200, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are supposed to work. I think that is OK. Philosophers may have opinions about that but
the question is not really relevant for theorieticsl or practical purposes.

Firstly, the HP is about the H that (If stated in C-function form, instead of TM) that:
H(P,P)=1 iff P(P) halts.
H(P,P)=0 iff P(P) does not halts.

Astray from this, it is not about the Halting Problem. HP is (almost) about a real machine, whatever logic,formal proof,philosophy,... is not decisive. olcott is a psychotic liar. he reads lots of technical terms and would post whatever he searched for you to head-ache (that is one of his trick), and  pretending he is a learned genius. He simply knows nothing.
E.g 'halt' --> no precise meaning
'Godel's theorem' --> no (significant) contents
'completeness' --> no (significant) contents
utm386 --> He can't construct TM for "1+2=3". He think his 'utm386' is an OS. C-language --> He needs debugger to understand, and took the complied assembly as 'totology' of his proof.
.... too many to list
Most of all, olcott does not even understand the logical-IF !!!
So, don't bother. olcott is a psychotic liar.

Anyone who wants to present or sell an emulating termination analyzer should tell what that particular analyzer actually does.

That's right.
But, in POO logic, olcott is always correct... just not interesting. No need  to argue (I though you and others engaged him for reasons).
The HP simply does not exist. POOH cannot perform the function as stated above. --- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On Mon, 2024-11-11 at 21:09 +0800, wij wrote:

On Mon, 2024-11-11 at 13:33 +0200, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are supposed to work. I think that is OK. Philosophers may have opinions about that but
the question is not really relevant for theorieticsl or practical purposes.

Firstly, the HP is about the H that (If stated in C-function form, instead of TM) that:

H(P,P)=1 iff P(P) halts.
H(P,P)=0 iff P(P) does not halts.
   
Astray from this, it is not about the Halting Problem. HP is (almost) about a real machine, whatever logic,formal proof,philosophy,... is not decisive.

olcott is a psychotic liar. he reads lots of technical terms and would post whatever he searched for you to head-ache (that is one of his trick), and  pretending he is a learned genius. He simply knows nothing.
E.g 'halt' --> no precise meaning
'Godel's theorem' --> no (significant) contents
'completeness' --> no (significant) contents
utm386 --> He can't construct TM for "1+2=3". He think his 'utm386' is an OS. C-language --> He needs debugger to understand, and took the complied assembly
as 'totology' of his proof.
.... too many to list
Most of all, olcott does not even understand the logical-IF !!!

So, don't bother. olcott is a psychotic liar.

Anyone who wants to present or sell an emulating termination analyzer should
tell what that particular analyzer actually does.

That's right.
But, in POO logic, olcott is always correct... just not interesting. No need 
to argue (I though you and others engaged him for reasons).

The HP simply does not exist. POOH cannot perform the function as stated above.

I just think about what I said about olcott, all symptoms might also applicable to average people, so, 'idiot' (too stupid) may be more truthful.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On Mon, 2024-11-11 at 21:28 +0800, wij wrote:

On Mon, 2024-11-11 at 21:09 +0800, wij wrote:

On Mon, 2024-11-11 at 13:33 +0200, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are supposed to
work. I think that is OK. Philosophers may have opinions about that but the question is not really relevant for theorieticsl or practical purposes.

Firstly, the HP is about the H that (If stated in C-function form, instead of
TM) that:

H(P,P)=1 iff P(P) halts.
H(P,P)=0 iff P(P) does not halts.
   
Astray from this, it is not about the Halting Problem. HP is (almost) about a
real machine, whatever logic,formal proof,philosophy,... is not decisive.

olcott is a psychotic liar. he reads lots of technical terms and would post whatever he searched for you to head-ache (that is one of his trick), and  pretending he is a learned genius. He simply knows nothing.
E.g 'halt' --> no precise meaning
'Godel's theorem' --> no (significant) contents
'completeness' --> no (significant) contents
utm386 --> He can't construct TM for "1+2=3". He think his 'utm386' is an OS.
C-language --> He needs debugger to understand, and took the complied assembly
as 'totology' of his proof.
.... too many to list
Most of all, olcott does not even understand the logical-IF !!!

So, don't bother. olcott is a psychotic liar.

Anyone who wants to present or sell an emulating termination analyzer should
tell what that particular analyzer actually does.

That's right.
But, in POO logic, olcott is always correct... just not interesting. No need 
to argue (I though you and others engaged him for reasons).

The HP simply does not exist. POOH cannot perform the function as stated above.

Sorry, typo found: The halting decider simply does not exist. POOH cannot perform 
the function as stated above.
I am not sensitive to English. There might be more in my previous post.

I just think about what I said about olcott, all symptoms might also applicable
to average people, so, 'idiot' (too stupid) may be more truthful.

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/11/2024 3:42 AM, Mikko wrote:

On 2024-11-10 19:28:28 +0000, olcott said:

*The best selling author of theory of computation textbooks*
<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>

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

No, that definition does not apply to Sipser's words. There a "correct simulation" measn a simulation that Sipser regards as correct, which
probably is the same as what "coreect simulation" means in Common
Language.

How could disagreeing with the semantics of the x86 language
possibly be correct?
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/10/24 11:28 PM, olcott wrote:

On 11/10/2024 9:55 PM, Richard Damon wrote:

On 11/10/24 10:18 PM, olcott wrote:

On 11/10/2024 9:09 PM, Richard Damon wrote:

On 11/10/24 9:14 PM, olcott wrote:

On 11/10/2024 7:20 PM, Richard Damon wrote:

On 11/10/24 7:27 PM, olcott wrote:

On 11/10/2024 6:06 PM, Richard Damon wrote:

On 11/10/24 6:19 PM, olcott wrote:

On 11/10/2024 4:53 PM, joes wrote:

Am Sun, 10 Nov 2024 15:45:37 -0600 schrieb olcott:

On 11/10/2024 3:02 PM, Richard Damon wrote:

On 11/10/24 2:28 PM, olcott wrote:

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

Right, if the correct (and thus complete) emulation of this >>>>>>>>>>>> precise
input would not halt.

That is what I have been saying for years.

If.

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>

Which your H doesn't do.

It is a matter of objective fact H does abort its emulation >>>>>>>>>>> and it does
reject its input D as non-halting.

And then it returns to the D that called it, which then halts >>>>>>>>>> anyway.

Maybe you are not as smart as ChatGPT.
ChatGPT cannot be convinced that HHH was not correct
to reject DDD as non-halting and explains in its own
words why the fact that DDD halts does not change this.

Sure it can. I did it, when I gave it a CORRECT description of >>>>>>>> the problem, it admits that your criteria for HHH is incorrect, >>>>>>>> and DDD does halt and HHH should have reported Halting.

When you try to argue that HHH does not correctly determine
that halt status of DDD within the succinct basis that I
provided you fail because my reasoning is inherently correct
within this basis.

You can't even convince it that my basis is based on false
assumptions it knows better.

ChatGPT
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution >>>>>>>>> to stop DDD() from running forever. But when HHH simulates DDD(), >>>>>>>>> it's analyzing an "idealized" version of DDD() where nothing >>>>>>>>> stops the
recursion. In the simulation, DDD() is seen as endlessly
recursive, so
HHH concludes that it would not halt without external
intervention.

Which has several lies in it, so makes your proof invalid.

https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2 >>>>>>>>> This link is live so you can try to convince ChatGPT that its >>>>>>>>> wrong.

DDD emulated by HHH has different behavior than DDD emulated >>>>>>>>> by HHH1 and it is becoming psychotic to keep ignoring this.

No, a correct emulation of ANY program will be the same no
matter what emulator looks at it.

No stupid this is not true.
You are stupid to disagree with the x86 language that
does proves that HHH emulates itself emulating DDD and
HHH1 does not emulate itself emulation DDD.

Are you going for a prize of maximum stupidity?

The problem is that you "basis" is just a lie, and doesn't meet
the requirements for a property to be decided by a decider.

That you think that you can get away with disagreeing with the
semantics of the x86 language for termination analyzer HHH
seems a little too stupid, thus we seem to be only left with
dishonestly.

WHERE did I disagree with the semantics of the x86 language?

You are just up to your old lies again.

The best judge of the x86 language is running the program described
by the input on a real CPU.

DDD() halts, so NOTHING in the x86 semantics can say otherwise, just
your LIES where you don't undetstand how computers actually work.

Saying that DDD() halts when you know damn well that
DDD emulated by HHH does not halt is a damned lie that
could get you condemned to actual Hell.

But DDD emulated by HHH doesn't say what the correct emulation per the
x86 language defines,

Yes it is and you are a liar for saying otherwise. Unless
you repent you many be a literally (condemned to actual Hell)
damned liar.

Then you can show where a PARTIAL emulation is considered correct, for
showing the final behavior of an progran, per the x86 language.

FINAL behavior is only indicated by COMPLETE emulation.

IF you don't get some braincells so you can understand what truth is,
YOU are going to find yourself having a one-way ticket to Gehenna.
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/11/24 8:58 AM, olcott wrote:

On 11/11/2024 3:42 AM, Mikko wrote:

On 2024-11-10 19:28:28 +0000, olcott said:

*The best selling author of theory of computation textbooks*
<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>

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

No, that definition does not apply to Sipser's words. There a "correct
simulation" measn a simulation that Sipser regards as correct, which
probably is the same as what "coreect simulation" means in Common
Language.

How could disagreeing with the semantics of the x86 language
possibly be correct?

The semantics of the x86 language are correct. You are just to stupid to undetstand what those are,
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/11/2024 5:33 AM, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are supposed to work.

When I provide direct access to fully operational code https://github.com/plolcott/x86utm/blob/master/Halt7.c
your statement becomes a bald faced lie.

I think that is OK. Philosophers may have opinions about that but
the question is not really relevant for theorieticsl or practical purposes.

Anyone who wants to present or sell an emulating termination analyzer
should
tell what that particular analyzer actually does.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 11/11/24 10:18 AM, olcott wrote:

On 11/11/2024 5:33 AM, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are
supposed to
work.

When I provide direct access to fully operational code https://github.com/plolcott/x86utm/blob/master/Halt7.c
your statement becomes a bald faced lie.

Except that your code isn't an example of how they are SUPPOSED to work,

After all, every one of your claimed examples says that its input is non-halting, when in fact, when we run that input, per the DEFINITION of
a termination analyzer, they halt.

Termination Analyzers are just incorrect to indicate that a halting
program is non-halting.

All you are doing is proving your ignorance of the systems you are
trying to claim making breakthroughs in.

I think that is OK. Philosophers may have opinions about that but
the question is not really relevant for theorieticsl or practical
purposes.

Anyone who wants to present or sell an emulating termination analyzer
should
tell what that particular analyzer actually does.

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 2024-11-11 13:58:54 +0000, olcott said:

On 11/11/2024 3:42 AM, Mikko wrote:

On 2024-11-10 19:28:28 +0000, olcott said:

*The best selling author of theory of computation textbooks*
<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>

Correct simulation is defined as D is emulated by H according to
the semantics of the x86 language thus includes H emulating itself
emulating D.

No, that definition does not apply to Sipser's words. There a "correct
simulation" measn a simulation that Sipser regards as correct, which
probably is the same as what "coreect simulation" means in Common
Language.

How could disagreeing with the semantics of the x86 language
possibly be correct?

The x86 is not relevant so neither the disagreement nor the
correctenss of any disagreement matters.
--
Mikko

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 2024-11-11 13:28:05 +0000, wij said:

On Mon, 2024-11-11 at 21:09 +0800, wij wrote:

On Mon, 2024-11-11 at 13:33 +0200, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are supposed to >>> work. I think that is OK. Philosophers may have opinions about that but
the question is not really relevant for theorieticsl or practical purposes. >>

Firstly, the HP is about the H that (If stated in C-function form, instead of
TM) that:

H(P,P)=1 iff P(P) halts.
H(P,P)=0 iff P(P) does not halts.
   > Astray from this, it is not about the Halting Problem. HP is
(almost) about a
real machine, whatever logic,formal proof,philosophy,... is not decisive.

olcott is a psychotic liar. he reads lots of technical terms and would post >> whatever he searched for you to head-ache (that is one of his trick), and  >> pretending he is a learned genius. He simply knows nothing.
E.g 'halt' --> no precise meaning
'Godel's theorem' --> no (significant) contents
'completeness' --> no (significant) contents
utm386 --> He can't construct TM for "1+2=3". He think his 'utm386' is an OS.
C-language --> He needs debugger to understand, and took the complied
assembly> as 'totology' of his proof.
.... too many to list
Most of all, olcott does not even understand the logical-IF !!!

So, don't bother. olcott is a psychotic liar.

Anyone who wants to present or sell an emulating termination analyzer should
tell what that particular analyzer actually does.

That's right.
But, in POO logic, olcott is always correct... just not interesting. No need 
to argue (I though you and others engaged him for reasons).

The HP simply does not exist. POOH cannot perform the function as stated above.

I just think about what I said about olcott, all symptoms might also applicable
to average people, so, 'idiot' (too stupid) may be more truthful.

I think "untrustworthy" or "unreliable" is sufficient.
--
Mikko

--- Synchronet 3.20a-Linux NewsLink 1.114

From Newsgroup: comp.theory

On 2024-11-11 15:18:55 +0000, olcott said:

On 11/11/2024 5:33 AM, Mikko wrote:

OP says nothing aobut how emulationg termination analyzers are supposed to >> work.

When I provide direct access to fully operational code https://github.com/plolcott/x86utm/blob/master/Halt7.c
your statement becomes a bald faced lie.

The page that link points to says nothing about termination analyzers.
--
Mikko

--- Synchronet 3.20a-Linux NewsLink 1.114