Re: ChatGPT refutes the key rebuttal of my work

On 10/16/24 8:26 AM, olcott wrote:

On 10/16/2024 1:30 AM, joes wrote:

Am Tue, 15 Oct 2024 21:23:52 -0500 schrieb olcott:

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

On 10/15/24 4:01 PM, olcott wrote:

On 10/15/2024 2:33 PM, joes wrote:

Am Tue, 15 Oct 2024 13:25:36 -0500 schrieb olcott:

On 10/15/2024 10:17 AM, joes wrote:

Am Tue, 15 Oct 2024 08:11:30 -0500 schrieb olcott:

On 10/15/2024 6:35 AM, Richard Damon wrote:

On 10/14/24 10:13 PM, olcott wrote:

On 10/14/2024 6:50 PM, Richard Damon wrote:

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

On 10/14/2024 7:06 AM, joes wrote:

Am Mon, 14 Oct 2024 04:49:22 -0500 schrieb olcott:

On 10/14/2024 4:04 AM, Mikko wrote:

On 2024-10-13 12:53:12 +0000, olcott said:

>

https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
When you click on the link and try to explain how HHH must be
wrong when it reports that DDD does not terminate because DDD
does terminate it will explain your mistake to you.

I did that, and it admitted that DDD halts, it just tries to
justify why a wrong answer must be right.

It explains in great detail that another different DDD (same
machine code different process context) seems to terminate only
because the recursive emulation that it specifies has been aborted
at its second recursive call.

Yes! It really has different code, by way of the static Root
variable.
No wonder it behaves differently.

There are no static root variables. There never has been any "not a
pure function of its inputs" aspect to emulation.

Oh, did you take out the check if HHH is the root simulator?

There is some code that was obsolete several years ago.

No, that code is still active. it is the source of the value for the
variable Root that is passed around, and is checked in the code to
alter the behavior.

It has no effect on the trace itself.

Other than producing a different trace. Seriously, why else should it
be in there?
>

 The whole purpose of the root variable to for storing
and examining the trace. It has nothing to do with the
actual x86 emulation.

No, it affect the decision to terminate.
And just having it makes your function unpure.
There is no room for excuses in purity.

 

It only affects the termination status decision that I conclusively
prove is unequivocally correct no matter how HHH detects this.

 

Sure, "DDD is the same program, except for a variable which directly
changes termination" lol.
>

 Without the root variable the trace would be the exact same
trace (except not terminate) thus the root variable has no
effect what-so-ever on the claim that I have been consistently
making for several weeks.

Nope, the trace through HHH changes when the emulated HHH (which has Root == 0) does something different than the outer emulating HHH did.
You just try to hide that fact by not showing the details, thus showing that you are knowing lying.

 void DDD()
{
   HHH(DDD);
   return;
}
 When HHH is an x86 emulation based termination analyzer then
each DDD *correctly_emulated_by* any HHH that it calls never returns.

Nope, because HHH doesn't DO a correct emuation that is usable to determine final behavior.

 Each of the directly executed HHH emulator/analyzers that returns
0 correctly reports the above *non_terminating _behavior* of its input.

Nope, as all of their DDD's can be proven to return, and thus they are wrong.
Your logic is based on fallacies,

 If HHH simply emulated N instructions of HHH and then returned
0 even this HHH would correctly report the above non-terminating
behavior. It didn't even look at its input and still got the
right answer.
 

Nope, as EVERY DDD that calls an HHH that returns ANYTHING will halt.
Thus ANY HHH that returns 0 is just wrong.
Your case just proves that you claimed criteria is invalid, and you show that HHH doesn't need to have done anything to actually determine the correct answer.
Sorry, you are just proving your utter stupidity,