Re: ChatGPT refutes the key rebuttal of my work

On 10/15/24 2:25 PM, olcott wrote:

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

ChatGPT does correctly apply truth preserving operations to the
premises that it was provided regarding the behavior of DDD and
HHH.
*Try to find a mistake in its reasoning*

No reasoning shown.

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.

It is nonsensical for HHH not to report that DDD terminates.

The explanation is quite good. I will take what you said to mean
that it was over your head or didn't bother to look at it.
You never confirmed that you even know what infinite recursion is.

No, he means your argument is just non-sense, and it is just a
blantant lie that you put forwards because you just don't understand
what you are talking about.,

In other words you coward away from trying to convince ChatGPT that is
is incorrect.

What do you mean. With one statement I got it to admit that the ACTUAL
behavior of DDD was to halt.
>
>

Since you say that it is a YES man it should be easy for you to get it
to admit that it is wrong.

Which I did,
>

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.

Really then where does the variable "Root" get its initial value from?
Answer, it looks at global memory and see if it has the pre-fill value of 0x90909090 or not.
Sorry, you are caught in that lie.
And then that gets put into your "Root" varialbe, and the abort criteria is only evaluated if Root is true.

 Every termination analyzer that emulates itself emulating
its input has always been a pure function of this input
up to the point where emulation stops.

Nope. you are just proving yourself to be a LIAR.
It seems you don't understand what a "pure function" means.
Note, unlike the term Computation, that if functional and not methodical, part of the definition of a "Pure Function" specifically outlaws certain code forms, like you program does.
SO, even if it didn't change its behavior, the mere fact that it does this check makes it not a "pure function"

 

You err because you fail to understand how the same C/x86 function
invoked in a different process context can have different behavior.

Do explain how a pure function can change.
>

 Non-terminating C functions do not ever return, thus cannot
possibly be pure functions.

But DDD does return, so can't be non-terminating.

 HHH is a pure function of its input the whole time that it
is emulating.

But that means it must ALWAYS return the same result for the same input, which means that the only correct conclusion of emulating a call HHH(DDD) instruction is to conclude that it returns.

 DDD has no inputs and is allowed to be any finite string
of x86 code. Inputs to HHH are by no means required to ever
return AT ALL. https://en.wikipedia.org/wiki/Pure_function
 

But, for DDD to have the property of termination, it must represent a COMPLETE computation, which means it include full definition of all the code that it runs, and that includes the HHH that it calls.
Since this DDD calls the exact same code as the HHH that returns 0 for the call to HHH(DDD), that code also returns 0 to that DDD, and thus that DDD is terminating.
Only because HHH uses incorrect logic does it conclude that its input isn't terminationg.
Part of that problem might be that it wasn't given a full input, or the problem might be that HHH does restrict itself to logic that remembers that the HHH that DDD calls is the HHH that is giving the answer, so when it hypotosizes that it is a different HHH that doesn't abort, it can't change the code for the HHH that DDD calls, like you logic tries to do, and thus is just unsound.