Although it is possible for LLM systems to lie: https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)
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*
*The key premises are simply*
(a) the source code for DDD
void DDD()
{
HHH(DDD);
return;
}
(b) The design of HHH as a simulating termination analyzer.
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
Click on the above link to directly talk to ChatGPT about HHH
and DDD without logging in.
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.
On 10/13/2024 8:19 AM, Richard Damon wrote:
On 10/13/24 8:53 AM, olcott wrote:
Although it is possible for LLM systems to lie:
https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)
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*
*The key premises are simply*
(a) the source code for DDD
WHich isn't the source code for the PROGRAM DDD
Try to run that program just by itself.
It won't work, you need to include HHH (and everything it calls) so
that the "source code" for DDD needs to include the definition of all
of that.
Sorry, you are just proving you don't understand what you are talking
about.
void DDD()
{
HHH(DDD);
return;
}
(b) The design of HHH as a simulating termination analyzer.
Which gets the wrong answer.
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
Click on the above link to directly talk to ChatGPT about HHH
and DDD without logging in.
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.
You have taught Chat GPT this error as shown in this statement:
I have only provided the source-code for DDD and the design of HHH.
You have not shown how any details of exactly what I told ChatGPT
are incorrect.
On 10/13/2024 1:49 PM, Richard Damon wrote:
On 10/13/24 9:28 AM, olcott wrote:
On 10/13/2024 8:19 AM, Richard Damon wrote:
On 10/13/24 8:53 AM, olcott wrote:
Although it is possible for LLM systems to lie:
https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence) >>>>>
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*
*The key premises are simply*
(a) the source code for DDD
WHich isn't the source code for the PROGRAM DDD
Try to run that program just by itself.
It won't work, you need to include HHH (and everything it calls) so
that the "source code" for DDD needs to include the definition of
all of that.
Sorry, you are just proving you don't understand what you are
talking about.
void DDD()
{
HHH(DDD);
return;
}
(b) The design of HHH as a simulating termination analyzer.
Which gets the wrong answer.
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
Click on the above link to directly talk to ChatGPT about HHH
and DDD without logging in.
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.
You have taught Chat GPT this error as shown in this statement:
I have only provided the source-code for DDD and the design of HHH.
You have not shown how any details of exactly what I told ChatGPT
are incorrect.
You mean like this statement:
The termination analyzer HHH is designed to detect non-terminating
behavior. When HHH simulates DDD and sees this pattern of infinite
recursive calls, it identifies that DDD will not terminate on its own.
I didn't say that. ChatGPT said that.
ChatGPT used the first page starting with "You said:"
as its entire basis.
*Everything that I said is indented two inches*
Everything that ChatGPT said is prefaced by its logo symbol.
Everything else that I said besides the first page
was merely a challenge to ChatGPT's understanding.
On 10/13/2024 6:49 PM, Richard Damon wrote:
On 10/13/24 3:29 PM, olcott wrote:
On 10/13/2024 1:49 PM, Richard Damon wrote:
On 10/13/24 9:28 AM, olcott wrote:
On 10/13/2024 8:19 AM, Richard Damon wrote:
On 10/13/24 8:53 AM, olcott wrote:
Although it is possible for LLM systems to lie:
https://en.wikipedia.org/wiki/
Hallucination_(artificial_intelligence)
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*
*The key premises are simply*
(a) the source code for DDD
WHich isn't the source code for the PROGRAM DDD
Try to run that program just by itself.
It won't work, you need to include HHH (and everything it calls)
so that the "source code" for DDD needs to include the definition
of all of that.
Sorry, you are just proving you don't understand what you are
talking about.
void DDD()
{
HHH(DDD);
return;
}
(b) The design of HHH as a simulating termination analyzer.
Which gets the wrong answer.
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
Click on the above link to directly talk to ChatGPT about HHH
and DDD without logging in.
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.
You have taught Chat GPT this error as shown in this statement:
I have only provided the source-code for DDD and the design of HHH.
You have not shown how any details of exactly what I told ChatGPT
are incorrect.
You mean like this statement:
The termination analyzer HHH is designed to detect non-terminating
behavior. When HHH simulates DDD and sees this pattern of infinite
recursive calls, it identifies that DDD will not terminate on its own. >>>>
I didn't say that. ChatGPT said that.
ChatGPT used the first page starting with "You said:"
as its entire basis.
*Everything that I said is indented two inches*
Everything that ChatGPT said is prefaced by its logo symbol.
So when you said:
Every C programmer that knows that when HHH emulates the machine
language of, Infinite_Recursion it must abort this emulation so that
itself can terminate normally.
When this is construed as non-halting criteria then simulating
termination analyzer HHH is correct to reject this input as non-
halting by returning 0 to its caller.
We get the same repetitive pattern when DDD is correctly emulated by
HHH. HHH emulates DDD that calls HHH(DDD) to do this again.
You LIED, as that is NOT the non-halting critera, and we do not get
the "same pattern"
I guess you don't understand the meaning of the words.
Arguements based on false premises are invalid.
I just asked it this:
Does HHH have correct non-halting criteria?
It explained all of the details of how you are wrong.
Try it yourself.
Although it is possible for LLM systems to lie: https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)
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*
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eChatGPT 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.
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.
On 10/14/2024 4:04 AM, Mikko wrote:
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)
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.
On 10/14/2024 6:21 AM, Richard Damon wrote:A program is a C function called from main(). This corresponds to the
On 10/14/24 5:49 AM, olcott wrote:It proves that it has a much deeper understanding than anything that I
On 10/14/2024 4:04 AM, Mikko wrote:No, it admits that DDD does halt, but that HHH must be correct to say
On 2024-10-13 12:53:12 +0000, olcott said:https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
Although it is possible for LLM systems to lie:No reasoning shown.
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*
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 doesn't, ... because of the lies you told it.
told it.
Its reasoning is based on the incorrect presumption that the HHH that(1) DDD never has been a program it is a C function.
DDD calls is not part of the program DDD,
(2) HHH does correctly emulated itself emulating DDD
this <is> a contiguous sequence of computation.
--because you have broken the definition of a program.I am not the one saying that a C function <is> a program.
You should not be so sloppy in your use of terminology.
DDD emulated by HHH including HHH emulating itself emulating DDD is a contiguous sequence of computation.
It is not and never has been a program. I think of DDD and HHH as
virtual machines.
On 10/14/2024 10:46 AM, joes wrote:
Am Mon, 14 Oct 2024 10:38:00 -0500 schrieb olcott:
On 10/14/2024 6:21 AM, Richard Damon wrote:A program is a C function called from main(). This corresponds to the
On 10/14/24 5:49 AM, olcott wrote:It proves that it has a much deeper understanding than anything that I
On 10/14/2024 4:04 AM, Mikko wrote:No, it admits that DDD does halt, but that HHH must be correct to say
On 2024-10-13 12:53:12 +0000, olcott said:https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
Although it is possible for LLM systems to lie:No reasoning shown.
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*
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 doesn't, ... because of the lies you told it.
told it.
Its reasoning is based on the incorrect presumption that the HHH that(1) DDD never has been a program it is a C function.
DDD calls is not part of the program DDD,
(2) HHH does correctly emulated itself emulating DDD
this <is> a contiguous sequence of computation.
behaviour of the actual execution.
I said that DDD never has never been a program and
you change the subject as your strawman deception rebuttal.
because you have broken the definition of a program.I am not the one saying that a C function <is> a program.
You should not be so sloppy in your use of terminology.
DDD emulated by HHH including HHH emulating itself emulating DDD is a
contiguous sequence of computation.
It is not and never has been a program. I think of DDD and HHH as
virtual machines.
On 10/14/2024 7:06 AM, joes wrote:
Am Mon, 14 Oct 2024 04:49:22 -0500 schrieb olcott:The explanation is quite good. I will take what you said
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eChatGPT 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.
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.
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.
On 10/14/2024 4:04 AM, Mikko wrote:
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence)
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.
On 10/14/2024 10:46 AM, joes wrote:What the fuck is wrong with you? I referred directly to your statement, disagreeing with it. DDD is a program the same way that HHH is. What
Am Mon, 14 Oct 2024 10:38:00 -0500 schrieb olcott:
On 10/14/2024 6:21 AM, Richard Damon wrote:
On 10/14/24 5:49 AM, olcott wrote:
On 10/14/2024 4:04 AM, Mikko wrote:
On 2024-10-13 12:53:12 +0000, olcott said:
I said that DDD never has never been a program and you change theA program is a C function called from main(). This corresponds to theIts reasoning is based on the incorrect presumption that the HHH that(1) DDD never has been a program it is a C function.
DDD calls is not part of the program DDD,
(2) HHH does correctly emulated itself emulating DDD
this <is> a contiguous sequence of computation.
behaviour of the actual execution.
subject as your strawman deception rebuttal.
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:The explanation is quite good. I will take what you said
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eChatGPT 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.
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.
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.
Since you say that it is a YES man it should be easy
for you to get it to admit that it is wrong.
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.
On 10/15/2024 6:35 AM, Richard Damon wrote:Yes! It really has different code, by way of the static Root variable.
On 10/14/24 10:13 PM, olcott wrote:It explains in great detail that another different DDD (same machine
On 10/14/2024 6:50 PM, Richard Damon wrote:What do you mean. With one statement I got it to admit that the ACTUAL
On 10/14/24 11:18 AM, olcott wrote:In other words you coward away from trying to convince ChatGPT that is
On 10/14/2024 7:06 AM, joes wrote:No, he means your argument is just non-sense, and it is just a
Am Mon, 14 Oct 2024 04:49:22 -0500 schrieb olcott:The explanation is quite good. I will take what you said to mean
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
On 2024-10-13 12:53:12 +0000, olcott said:https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e
ChatGPT does correctly apply truth preserving operations to the >>>>>>>>> premises that it was provided regarding the behavior of DDD and >>>>>>>>> HHH.No reasoning shown.
*Try to find a mistake in its reasoning*
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.
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.
blantant lie that you put forwards because you just don't understand
what you are talking about.,
is incorrect.
behavior of DDD was to halt.
Since you say that it is a YES man it should be easy for you to get itWhich I did,
to admit that it is wrong.
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eI did that, and it admitted that DDD halts, it just tries to justify
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.
why a wrong answer must be right.
code different process context) seems to terminate only because the
recursive emulation that it specifies has been aborted at its second recursive call.
You err because you fail to understand how the same C/x86 functionDo explain how a pure function can change.
invoked in a different process context can have different behavior.
On 10/15/2024 10:17 AM, joes wrote:Oh, did you take out the check if HHH is the root simulator?
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:
There are no static root variables. There never has been any "not a pure function of its inputs" aspect to emulation.Yes! It really has different code, by way of the static Root variable.It explains in great detail that another different DDD (same machinehttps://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e WhenI did that, and it admitted that DDD halts, it just tries to justify
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.
why a wrong answer must be right.
code different process context) seems to terminate only because the
recursive emulation that it specifies has been aborted at its second
recursive call.
No wonder it behaves differently.
Every termination analyzer that emulates itself emulating its input has always been a pure function of this input up to the point whereThat point can never come in the complete simulation of a non-
emulation stops.
By "pure" I mean having no side effects. You mean total vs. partial.Non-terminating C functions do not ever return, thus cannot possibly beYou err because you fail to understand how the same C/x86 functionDo explain how a pure function can change.
invoked in a different process context can have different behavior.
pure functions.
HHH is a pure function of its input the whole time that it is emulating.I thought DDD was fixed to only call HHH(DDD)?
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.
On 10/15/2024 2:33 PM, joes wrote:I don't follow your repo. Can you point me to the relevant commit?
Am Tue, 15 Oct 2024 13:25:36 -0500 schrieb olcott:There is some code that was obsolete several years ago.
On 10/15/2024 10:17 AM, joes wrote:Oh, did you take out the check if HHH is the root simulator?
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:
There are no static root variables. There never has been any "not aYes! It really has different code, by way of the static RootIt explains in great detail that another different DDD (same machine >>>>> code different process context) seems to terminate only because thehttps://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eI did that, and it admitted that DDD halts, it just tries to
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.
justify why a wrong answer must be right.
recursive emulation that it specifies has been aborted at its second >>>>> recursive call.
variable.
No wonder it behaves differently.
pure function of its inputs" aspect to emulation.
You seemed to not understand that a simulation may be nonterminating.You and Richard never seemed to understand this previously.Every termination analyzer that emulates itself emulating its inputThat point can never come in the complete simulation of a non-
has always been a pure function of this input up to the point where
emulation stops.
terminating input, because it is infinite.
Sure. How can a function without side effects have different behaviour?You may be half right. Only the analyzer must be pure.By "pure" I mean having no side effects. You mean total vs. partial.Non-terminating C functions do not ever return, thus cannot possiblyYou err because you fail to understand how the same C/x86 functionDo explain how a pure function can change.
invoked in a different process context can have different behavior.
be pure functions.
The input is free to get stuck in an infinite loop.
Weren't we discussing the halting DDD(){HHH(DDD);} before?Inputs are not required to be pure functions.HHH is a pure function of its input the whole time that it isI thought DDD was fixed to only call HHH(DDD)?
emulating.
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.
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:
There are no static root variables. There never has been any "not a pure >>> function of its inputs" aspect to emulation.Yes! It really has different code, by way of the static Root variable. >>>> No wonder it behaves differently.It explains in great detail that another different DDD (same machine >>>>> code different process context) seems to terminate only because thehttps://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.
recursive emulation that it specifies has been aborted at its second >>>>> recursive call.
Oh, did you take out the check if HHH is the root simulator?
There is some code that was obsolete several years ago.
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.
That point can never come in the complete simulation of a non-You and Richard never seemed to understand this previously.
terminating input, because it is infinite.
Non-terminating C functions do not ever return, thus cannot possibly beYou err because you fail to understand how the same C/x86 functionDo explain how a pure function can change.
invoked in a different process context can have different behavior.
pure functions.
By "pure" I mean having no side effects. You mean total vs. partial.
You may be half right.
https://en.wikipedia.org/wiki/Pure_function
Only the analyzer must be pure.
The input is free to get stuck in an infinite loop.
HHH is a pure function of its input the whole time that it is emulating. >>> 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.
I thought DDD was fixed to only call HHH(DDD)?
Inputs are not required to be pure functions.
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:Yes! It really has different code, by way of the static Root variable.
On 10/14/24 10:13 PM, olcott wrote:It explains in great detail that another different DDD (same machine
On 10/14/2024 6:50 PM, Richard Damon wrote:What do you mean. With one statement I got it to admit that the ACTUAL >>>> behavior of DDD was to halt.
On 10/14/24 11:18 AM, olcott wrote:In other words you coward away from trying to convince ChatGPT that is >>>>> is incorrect.
On 10/14/2024 7:06 AM, joes wrote:blantant lie that you put forwards because you just don't understand >>>>>> what you are talking about.,
Am Mon, 14 Oct 2024 04:49:22 -0500 schrieb olcott: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.
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
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.
ChatGPT does correctly apply truth preserving operations to the >>>>>>>>>>> premises that it was provided regarding the behavior of DDD and >>>>>>>>>>> HHH.No reasoning shown.
*Try to find a mistake in its reasoning*
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
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-27066fb49f3eI did that, and it admitted that DDD halts, it just tries to justify
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.
why a wrong answer must be right.
code different process context) seems to terminate only because the
recursive emulation that it specifies has been aborted at its second
recursive call.
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.
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.
You err because you fail to understand how the same C/x86 functionDo explain how a pure function can change.
invoked in a different process context can have different behavior.
Non-terminating C functions do not ever return, thus cannot
possibly be pure functions.
HHH is a pure function of its input the whole time that it
is emulating.
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
On 10/15/2024 9:11 PM, Richard Damon wrote:Other than producing a different trace. Seriously, why else should it
On 10/15/24 4:01 PM, olcott wrote:It has no effect on the trace itself.
On 10/15/2024 2:33 PM, joes wrote:No, that code is still active. it is the source of the value for the
Am Tue, 15 Oct 2024 13:25:36 -0500 schrieb olcott:There is some code that was obsolete several years ago.
On 10/15/2024 10:17 AM, joes wrote:Oh, did you take out the check if HHH is the root simulator?
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:
There are no static root variables. There never has been any "not aYes! It really has different code, by way of the static RootIt explains in great detail that another different DDD (samehttps://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.
machine code different process context) seems to terminate only
because the recursive emulation that it specifies has been aborted >>>>>>> at its second recursive call.
variable.
No wonder it behaves differently.
pure function of its inputs" aspect to emulation.
variable Root that is passed around, and is checked in the code to
alter the behavior.
It only affects the termination status decision that I conclusivelySure, "DDD is the same program, except for a variable which directly
prove is unequivocally correct no matter how HHH detects this.
On 10/15/2024 4:24 PM, joes wrote:Nope, still there: https://github.com/plolcott/x86utm/blob/master/
Am Tue, 15 Oct 2024 15:01:36 -0500 schrieb olcott:https://github.com/plolcott/x86utm Halt7.c was updated last month.
On 10/15/2024 2:33 PM, joes wrote:I don't follow your repo. Can you point me to the relevant commit?
Am Tue, 15 Oct 2024 13:25:36 -0500 schrieb olcott:There is some code that was obsolete several years ago.
On 10/15/2024 10:17 AM, joes wrote:Oh, did you take out the check if HHH is the root simulator?
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:
There are no static root variables. There never has been any "not aYes! It really has different code, by way of the static RootIt explains in great detail that another different DDD (samehttps://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.
machine code different process context) seems to terminate only
because the recursive emulation that it specifies has been aborted >>>>>>> at its second recursive call.
variable.
No wonder it behaves differently.
pure function of its inputs" aspect to emulation.
It doesn't seem to have happened this year.
Sure.Sure yet only when the input is non-terminating.You seemed to not understand that a simulation may be nonterminating.You and Richard never seemed to understand this previously.Every termination analyzer that emulates itself emulating its inputThat point can never come in the complete simulation of a non-
has always been a pure function of this input up to the point where
emulation stops.
terminating input, because it is infinite.
In which way is DDD screwed up that it is both free of side effects and referentially intransparent?DDD is free to be totally screwed up every which way.Sure. How can a function without side effects have different behaviour?You may be half right. Only the analyzer must be pure.By "pure" I mean having no side effects. You mean total vs. partial.Non-terminating C functions do not ever return, thus cannot possibly >>>>> be pure functions.You err because you fail to understand how the same C/x86 function >>>>>>> invoked in a different process context can have differentDo explain how a pure function can change.
behavior.
The input is free to get stuck in an infinite loop.
It is only HHH that must be a pure function.
I am, as of a couple months back. This is still related to the Linz proof.For many months now I have been talking about the termination analyzerWeren't we discussing the halting DDD(){HHH(DDD);} before?Inputs are not required to be pure functions.HHH is a pure function of its input the whole time that it isI thought DDD was fixed to only call HHH(DDD)?
emulating.
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.
HHH applied to input DDD.
I am not aware of ever referring to HHH as a halt decider. When I talk
about halt deciders I talk about the Linz proof.
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:
There are no static root variables. There never has been any "not aYes! It really has different code, by way of the static RootIt 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.https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3e >>>>>>>>> WhenI did that, and it admitted that DDD halts, it just tries to
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.
justify
why a wrong answer must be right.
variable.
No wonder it behaves differently.
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.
It only effects the termination status decision
that I conclusively prove is unequivocally correct
no matter how HHH detects this.
Every HHH that returns 0 correctly reports that DDD
emulated by HHH cannot possible reach its own return
instruction EVEN IF HHH DOES THIS BY WILD GUESS.
Of every HHH that returns anything at all, the
ones that return 0 are necessarily correct.
On 10/16/2024 1:30 AM, joes wrote:Nope. It is a flag for checking if we are in the outermost simulator.
Am Tue, 15 Oct 2024 21:23:52 -0500 schrieb olcott:The whole purpose of the root variable to for storing and examining the trace. It has nothing to do with the actual x86 emulation.
On 10/15/2024 9:11 PM, Richard Damon wrote:Other than producing a different trace. Seriously, why else should it
On 10/15/24 4:01 PM, olcott wrote:It has no effect on the trace itself.
On 10/15/2024 2:33 PM, joes wrote:No, that code is still active. it is the source of the value for the
Am Tue, 15 Oct 2024 13:25:36 -0500 schrieb olcott:There is some code that was obsolete several years ago.
On 10/15/2024 10:17 AM, joes wrote:Oh, did you take out the check if HHH is the root simulator?
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:
There are no static root variables. There never has been any "not >>>>>>> a pure function of its inputs" aspect to emulation.Yes! It really has different code, by way of the static RootIt 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 beenhttps://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.
aborted at its second recursive call.
variable.
No wonder it behaves differently.
variable Root that is passed around, and is checked in the code to
alter the behavior.
be in there?
Exactly! It is only for changing the answer HHH gives about DDD. ThatWithout the root variable the trace would be the exact same traceIt only affects the termination status decision that I conclusivelySure, "DDD is the same program, except for a variable which directly
prove is unequivocally correct no matter how HHH detects this.
changes termination" lol.
(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.
On 10/16/2024 1:33 AM, joes wrote:Line 502 (if(Root)) wasn't changed.
Am Tue, 15 Oct 2024 16:51:15 -0500 schrieb olcott:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502 shows: u32
On 10/15/2024 4:24 PM, joes wrote:Nope, still there: https://github.com/plolcott/x86utm/blob/master/
Am Tue, 15 Oct 2024 15:01:36 -0500 schrieb olcott:https://github.com/plolcott/x86utm Halt7.c was updated last month.
On 10/15/2024 2:33 PM, joes wrote:I don't follow your repo. Can you point me to the relevant commit?
Am Tue, 15 Oct 2024 13:25:36 -0500 schrieb olcott:There is some code that was obsolete several years ago.
On 10/15/2024 10:17 AM, joes wrote:Oh, did you take out the check if HHH is the root simulator?
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:
There are no static root variables. There never has been any "not >>>>>>> a pure function of its inputs" aspect to emulation.Yes! It really has different code, by way of the static RootIt 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 beenhttps://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.
aborted at its second recursive call.
variable.
No wonder it behaves differently.
It doesn't seem to have happened this year.
Halt7.c#L502
H(ptr P, ptr I) // 2024-09-15 was HH and edit on line 643
The repository indicates that it was updated: "last month"
I am talking about the referential transparency, not whether the functionTherefore if HHH even guesses that its input is non-termination then HHHSure.Sure yet only when the input is non-terminating.You seemed to not understand that a simulation may be nonterminating.You and Richard never seemed to understand this previously.Every termination analyzer that emulates itself emulating itsThat point can never come in the complete simulation of a non-
input has always been a pure function of this input up to the
point where emulation stops.
terminating input, because it is infinite.
is correct.
In other words you don't have a clue that an input to a terminationIn which way is DDD screwed up that it is both free of side effects andDDD is free to be totally screwed up every which way.Sure. How can a function without side effects have differentYou may be half right. Only the analyzer must be pure.By "pure" I mean having no side effects. You mean total vs.Non-terminating C functions do not ever return, thus cannotYou err because you fail to understand how the same C/x86Do explain how a pure function can change.
function invoked in a different process context can have
different behavior.
possibly be pure functions.
partial.
The input is free to get stuck in an infinite loop.
behaviour?
It is only HHH that must be a pure function.
referentially intransparent?
analyzer can be non-terminating thus violating the (1) criteria of pure functions shown below.
(1) *the function return values are identical for identical arguments*Yes, this has nothing to do with termination. Your function Decide_Halting_HH(..., u32 Root) (line 473) is not pure though.
(no variation with local static variables, non-local variables, mutable reference arguments or input streams, i.e., referential transparency),
and (2) the function has no side effects (no mutation of local static variables, non-local variables, mutable reference arguments or input/
output streams).
When-so-ever any input to a termination analyzer iss/pure/total
non-terminating for any reason then this input is not a pure function.
Terminating C functions must reach their "return" statement.Which DDD does.
--I am, as of a couple months back. This is still related to the LinzFor many months now I have been talking about the termination analyzerWeren't we discussing the halting DDD(){HHH(DDD);} before?Inputs are not required to be pure functions.HHH is a pure function of its input the whole time that it isI thought DDD was fixed to only call HHH(DDD)?
emulating.
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.
HHH applied to input DDD.
I am not aware of ever referring to HHH as a halt decider. When I talk
about halt deciders I talk about the Linz proof.
proof.
On 10/16/2024 9:01 AM, joes wrote:You are not simulating the given program, but a version that differs
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott:
On 10/16/2024 1:33 AM, joes wrote:
Am Tue, 15 Oct 2024 16:51:15 -0500 schrieb olcott:
On 10/15/2024 4:24 PM, joes wrote:
Am Tue, 15 Oct 2024 15:01:36 -0500 schrieb olcott:
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:
Line 502 (if(Root)) wasn't changed.https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502 shows: u32Nope, still there: https://github.com/plolcott/x86utm/blob/master/https://github.com/plolcott/x86utm Halt7.c was updated last month.I don't follow your repo. Can you point me to the relevant commit? >>>>>> It doesn't seem to have happened this year.There is some code that was obsolete several years ago.Oh, did you take out the check if HHH is the root simulator?There are no static root variables. There never has been any >>>>>>>>> "not a pure function of its inputs" aspect to emulation.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.
Halt7.c#L502
H(ptr P, ptr I) // 2024-09-15 was HH and edit on line 643 The
repository indicates that it was updated: "last month"
I am talking about the referential transparency, not whether theIn other words you don't have a clue that an input to a terminationIn which way is DDD screwed up that it is both free of side effectsDDD is free to be totally screwed up every which way.Sure. How can a function without side effects have differentYou may be half right. Only the analyzer must be pure.By "pure" I mean having no side effects. You mean total vs.Non-terminating C functions do not ever return, thus cannotYou 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.
possibly be pure functions.
partial.
The input is free to get stuck in an infinite loop.
behaviour?
It is only HHH that must be a pure function.
and referentially intransparent?
analyzer can be non-terminating thus violating the (1) criteria of
pure functions shown below.
function is total or partial.
(1) *the function return values are identical for identical arguments*Yes, this has nothing to do with termination. Your function
(no variation with local static variables, non-local variables,
mutable reference arguments or input streams, i.e., referential
transparency), and (2) the function has no side effects (no mutation
of local static variables, non-local variables, mutable reference
arguments or input/ output streams).
Decide_Halting_HH(..., u32 Root) (line 473) is not pure though.
When-so-ever any input to a termination analyzer is non-terminatings/pure/total
for any reason then this input is not a pure function.
Terminating C functions must reach their "return" statement.Which DDD does.
THIS IS ALSO THE INDUSTRY STANDARD DEFINITION It is stipulated that *correct_x86_emulation* means that a finite string of x86 instructions
is emulated according to the semantics of the x86 language beginning
with the first bytes of this string.
When HHH is an x86 emulation based termination analyzer then each DDD *correctly_emulated_by* any HHH that it calls never returns.It is not a correct emulation if it has a different termination status.
On 10/16/2024 8:27 AM, joes wrote:Two sequences of different lengths are not the same, even though they
Am Wed, 16 Oct 2024 07:26:37 -0500 schrieb olcott:
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:
This has no effect on the sequence of correctly emulated steps.Nope. It is a flag for checking if we are in the outermost simulator.The whole purpose of the root variable to for storing and examiningOther than producing a different trace. Seriously, why else should itIt has no effect on the trace itself.No, that code is still active. it is the source of the value forThere is some code that was obsolete several years ago.Oh, did you take out the check if HHH is the root simulator?There are no static root variables. There never has been any >>>>>>>>> "not a pure function of its inputs" aspect to emulation.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.
the variable Root that is passed around, and is checked in the code >>>>>> to alter the behavior.
be in there?
the trace. It has nothing to do with the actual x86 emulation.
It only has an effect of the length of this sequence.
At the time that HHH aborts its emulation there is already completeThe fact that it aborts changes the answer, by virtue of the recursive simulation.
proof that it was required to abort this sequence to prevent its own non-termination.
We are only quibbling over whether or not it saw this complete proof inNo, it does not give the right answer.
the proper way.
It changes the trace of HHH to abort simulating.Exactly! It is only for changing the answer HHH gives about DDD.Without the root variable the trace would be the exact same traceIt only affects the termination status decision that I conclusivelySure, "DDD is the same program, except for a variable which directly
prove is unequivocally correct no matter how HHH detects this.
changes termination" lol.
(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.
That changes the whole trace except for the first few instructions.It does not change any aspect of the trace until the trace conclusively proves that DDD cannot possibly ever reach its own "return" instruction
no matter what HHH does.
On 10/15/2024 3:27 AM, Mikko wrote:
On 2024-10-14 09:49:22 +0000, olcott said:
On 10/14/2024 4:04 AM, Mikko wrote:
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://en.wikipedia.org/wiki/Hallucination_(artificial_intelligence) >>>>>
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.
Possibly, but you have not shown any reasoning. The only relevant
things on the page behind the link is:
Everything after the first page is reasoning provided
by ChatGPT. Everything that I provide after the first
page merely challenges the reasoning provided by ChatGPT.
On 10/15/2024 3:33 AM, Mikko wrote:
On 2024-10-14 15:18:43 +0000, olcott said:
On 10/14/2024 7:06 AM, joes wrote:
Am Mon, 14 Oct 2024 04:49:22 -0500 schrieb olcott:The explanation is quite good. I will take what you said
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eChatGPT 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.
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.
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.
Could you confirm that you know whether there is an infinite recursion
in DDD?
Recursive emulation is isomorphic to recursion.
The following is to be understood only within my
stipulative definitions of terms provided in my first
reply to you today.
Recursive emulation that does not have a termination
condition within the c function under test is infinite.
This refers to my stipulative definition of terms
provided in my first reply to you. To the best of my
knowledge these definitions are also industry standard.
On 10/16/2024 9:45 AM, joes wrote:Whereupon the simulated HHH would abort, if it weren't unnecessarily
Am Wed, 16 Oct 2024 09:11:22 -0500 schrieb olcott:
On 10/16/2024 9:01 AM, joes wrote:
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott:
On 10/16/2024 1:33 AM, joes wrote:
Am Tue, 15 Oct 2024 16:51:15 -0500 schrieb olcott:
On 10/15/2024 4:24 PM, joes wrote:
HHH is correctly emulating (not simulating) the x86 language finiteYou are not simulating the given program, but a version that differs inTHIS IS ALSO THE INDUSTRY STANDARD DEFINITION It is stipulated thatTerminating C functions must reach their "return" statement.Which DDD does.
*correct_x86_emulation* means that a finite string of x86 instructions
is emulated according to the semantics of the x86 language beginning
with the first bytes of this string.
the abort check.
string of DDD including emulating the finite string of itself emulating
the finite string of DDD up until the point where the emulated emulated
DDD would call HHH(DDD) again.
--When HHH is an x86 emulation based termination analyzer then each DDDIt is not a correct emulation if it has a different termination status.
*correctly_emulated_by* any HHH that it calls never returns.
On 10/16/2024 12:27 PM, joes wrote:And if the first one does, all of them do.
Am Wed, 16 Oct 2024 10:39:21 -0500 schrieb olcott:If the first HHH to meet its abort criteria does not act on this
On 10/16/2024 9:45 AM, joes wrote:Whereupon the simulated HHH would abort, if it weren't unnecessarily
Am Wed, 16 Oct 2024 09:11:22 -0500 schrieb olcott:
On 10/16/2024 9:01 AM, joes wrote:
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott:
On 10/16/2024 1:33 AM, joes wrote:
Am Tue, 15 Oct 2024 16:51:15 -0500 schrieb olcott:
On 10/15/2024 4:24 PM, joes wrote:
HHH is correctly emulating (not simulating) the x86 language finiteYou are not simulating the given program, but a version that differsTHIS IS ALSO THE INDUSTRY STANDARD DEFINITION It is stipulated thatTerminating C functions must reach their "return" statement.Which DDD does.
*correct_x86_emulation* means that a finite string of x86
instructions is emulated according to the semantics of the x86
language beginning with the first bytes of this string.
in the abort check.
string of DDD including emulating the finite string of itself
emulating the finite string of DDD up until the point where the
emulated emulated DDD would call HHH(DDD) again.
aborted.
criteria then none of them do.
--When HHH is an x86 emulation based termination analyzer then eachIt is not a correct emulation if it has a different termination
DDD *correctly_emulated_by* any HHH that it calls never returns.
status.
On 10/16/2024 1:06 PM, joes wrote:In practice you programmed H impurely.
Am Wed, 16 Oct 2024 12:46:01 -0500 schrieb olcott:
On 10/16/2024 12:27 PM, joes wrote:
Am Wed, 16 Oct 2024 10:39:21 -0500 schrieb olcott:
On 10/16/2024 9:45 AM, joes wrote:
Am Wed, 16 Oct 2024 09:11:22 -0500 schrieb olcott:
On 10/16/2024 9:01 AM, joes wrote:
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott:
On 10/16/2024 1:33 AM, joes wrote:
In theory this seems true when ignoring or failing to comprehend keyAnd if the first one does, all of them do.If the first HHH to meet its abort criteria does not act on thisWhereupon the simulated HHH would abort, if it weren't unnecessarilyHHH is correctly emulating (not simulating) the x86 language finiteYou are not simulating the given program, but a version thatTHIS IS ALSO THE INDUSTRY STANDARD DEFINITION It is stipulatedTerminating C functions must reach their "return" statement.Which DDD does.
that *correct_x86_emulation* means that a finite string of x86
instructions is emulated according to the semantics of the x86
language beginning with the first bytes of this string.
differs in the abort check.
string of DDD including emulating the finite string of itself
emulating the finite string of DDD up until the point where the
emulated emulated DDD would call HHH(DDD) again.
aborted.
criteria then none of them do.
details.
--When HHH is an x86 emulation based termination analyzer then each >>>>>>> DDD *correctly_emulated_by* any HHH that it calls never returns.It is not a correct emulation if it has a different termination
status.
On 10/16/2024 1:47 PM, joes wrote:Exactly, because your nested HHHs do not abort.
Am Wed, 16 Oct 2024 13:35:01 -0500 schrieb olcott:Which totally does not matter to the slightest degree when you have the discipline to stay within the precisely designated scope of the exact
On 10/16/2024 1:06 PM, joes wrote:In practice you programmed H impurely.
Am Wed, 16 Oct 2024 12:46:01 -0500 schrieb olcott:
On 10/16/2024 12:27 PM, joes wrote:
Am Wed, 16 Oct 2024 10:39:21 -0500 schrieb olcott:
On 10/16/2024 9:45 AM, joes wrote:
Am Wed, 16 Oct 2024 09:11:22 -0500 schrieb olcott:
On 10/16/2024 9:01 AM, joes wrote:
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott:
On 10/16/2024 1:33 AM, joes wrote:
In theory this seems true when ignoring or failing to comprehend keyAnd if the first one does, all of them do.If the first HHH to meet its abort criteria does not act on thisWhereupon the simulated HHH would abort, if it weren'tHHH is correctly emulating (not simulating) the x86 languageYou are not simulating the given program, but a version thatTHIS IS ALSO THE INDUSTRY STANDARD DEFINITION It is stipulated >>>>>>>>> that *correct_x86_emulation* means that a finite string of x86 >>>>>>>>> instructions is emulated according to the semantics of the x86 >>>>>>>>> language beginning with the first bytes of this string.Terminating C functions must reach their "return" statement. >>>>>>>>>> Which DDD does.
differs in the abort check.
finite string of DDD including emulating the finite string of
itself emulating the finite string of DDD up until the point where >>>>>>> the emulated emulated DDD would call HHH(DDD) again.
unnecessarily aborted.
criteria then none of them do.
details.
words that I am saying.
When HHH is an x86 emulation based termination analyzer then each DDD *correctly_emulated_by* any HHH that it calls cannot possibly return no matter what this HHH does.
--When HHH is an x86 emulation based termination analyzer then >>>>>>>>> each DDD *correctly_emulated_by* any HHH that it calls never >>>>>>>>> returns.It is not a correct emulation if it has a different termination >>>>>>>> status.
On 10/16/2024 2:33 PM, joes wrote:Then HHH should report itself as halting, when they would all abort.
Am Wed, 16 Oct 2024 13:59:58 -0500 schrieb olcott:In other words you continue to fail to understand that unless the first
On 10/16/2024 1:47 PM, joes wrote:Exactly, because your nested HHHs do not abort.
Am Wed, 16 Oct 2024 13:35:01 -0500 schrieb olcott:Which totally does not matter to the slightest degree when you have
On 10/16/2024 1:06 PM, joes wrote:In practice you programmed H impurely.
Am Wed, 16 Oct 2024 12:46:01 -0500 schrieb olcott:
On 10/16/2024 12:27 PM, joes wrote:
Am Wed, 16 Oct 2024 10:39:21 -0500 schrieb olcott:
On 10/16/2024 9:45 AM, joes wrote:
Am Wed, 16 Oct 2024 09:11:22 -0500 schrieb olcott:
On 10/16/2024 9:01 AM, joes wrote:
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott:
On 10/16/2024 1:33 AM, joes wrote:
In theory this seems true when ignoring or failing to comprehend key >>>>> details.And if the first one does, all of them do.If the first HHH to meet its abort criteria does not act on this >>>>>>> criteria then none of them do.Whereupon the simulated HHH would abort, if it weren'tHHH is correctly emulating (not simulating) the x86 language >>>>>>>>> finite string of DDD including emulating the finite string of >>>>>>>>> itself emulating the finite string of DDD up until the point >>>>>>>>> where the emulated emulated DDD would call HHH(DDD) again.You are not simulating the given program, but a version that >>>>>>>>>> differs in the abort check.THIS IS ALSO THE INDUSTRY STANDARD DEFINITION It is stipulated >>>>>>>>>>> that *correct_x86_emulation* means that a finite string of x86 >>>>>>>>>>> instructions is emulated according to the semantics of the x86 >>>>>>>>>>> language beginning with the first bytes of this string.Terminating C functions must reach their "return" statement. >>>>>>>>>>>> Which DDD does.
unnecessarily aborted.
the discipline to stay within the precisely designated scope of the
exact words that I am saying.
When HHH is an x86 emulation based termination analyzer then each DDD
*correctly_emulated_by* any HHH that it calls cannot possibly return
no matter what this HHH does.
one aborts then none of them can possibly abort because they all have
the exact same code.
--When HHH is an x86 emulation based termination analyzer then >>>>>>>>>>> each DDD *correctly_emulated_by* any HHH that it calls never >>>>>>>>>>> returns.It is not a correct emulation if it has a different termination >>>>>>>>>> status.
On 10/16/2024 11:23 AM, Mikko wrote:
On 2024-10-15 12:57:25 +0000, olcott said:
On 10/15/2024 3:33 AM, Mikko wrote:
On 2024-10-14 15:18:43 +0000, olcott said:
On 10/14/2024 7:06 AM, joes wrote:
Am Mon, 14 Oct 2024 04:49:22 -0500 schrieb olcott:The explanation is quite good. I will take what you said
On 10/14/2024 4:04 AM, Mikko wrote:It is nonsensical for HHH not to report that DDD terminates.
On 2024-10-13 12:53:12 +0000, olcott said:
Although it is possible for LLM systems to lie:
https://chatgpt.com/share/6709e046-4794-8011-98b7-27066fb49f3eChatGPT 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.
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.
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.
Could you confirm that you know whether there is an infinite recursion >>>> in DDD?
Recursive emulation is isomorphic to recursion.
The following is to be understood only within my
stipulative definitions of terms provided in my first
reply to you today.
Recursive emulation that does not have a termination
condition within the c function under test is infinite.
This refers to my stipulative definition of terms
provided in my first reply to you. To the best of my
knowledge these definitions are also industry standard.
This can be interpreted as an overly verbose 'No'.
I will equally say that you are wrong.
On 10/16/2024 3:02 PM, joes wrote:Only because they aren't simulated. But they are still terminating
Am Wed, 16 Oct 2024 14:39:37 -0500 schrieb olcott:They would not all abort when you pay close attention to ALL of the
On 10/16/2024 2:33 PM, joes wrote:Then HHH should report itself as halting, when they would all abort.
Am Wed, 16 Oct 2024 13:59:58 -0500 schrieb olcott:In other words you continue to fail to understand that unless the
On 10/16/2024 1:47 PM, joes wrote:Exactly, because your nested HHHs do not abort.
Am Wed, 16 Oct 2024 13:35:01 -0500 schrieb olcott:Which totally does not matter to the slightest degree when you have
On 10/16/2024 1:06 PM, joes wrote:In practice you programmed H impurely.
Am Wed, 16 Oct 2024 12:46:01 -0500 schrieb olcott:
On 10/16/2024 12:27 PM, joes wrote:
Am Wed, 16 Oct 2024 10:39:21 -0500 schrieb olcott:
On 10/16/2024 9:45 AM, joes wrote:
Am Wed, 16 Oct 2024 09:11:22 -0500 schrieb olcott:
On 10/16/2024 9:01 AM, joes wrote:
Am Wed, 16 Oct 2024 08:31:43 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 10/16/2024 1:33 AM, joes wrote:
In theory this seems true when ignoring or failing to comprehend >>>>>>> key details.And if the first one does, all of them do.If the first HHH to meet its abort criteria does not act on this >>>>>>>>> criteria then none of them do.unnecessarily aborted.HHH is correctly emulating (not simulating) the x86 language >>>>>>>>>>> finite string of DDD including emulating the finite string of >>>>>>>>>>> itself emulating the finite string of DDD up until the point >>>>>>>>>>> where the emulated emulated DDD would call HHH(DDD) again. >>>>>>>>>> Whereupon the simulated HHH would abort, if it weren'tYou are not simulating the given program, but a version that >>>>>>>>>>>> differs in the abort check.THIS IS ALSO THE INDUSTRY STANDARD DEFINITION It isTerminating C functions must reach their "return" >>>>>>>>>>>>>>> statement.Which DDD does.
stipulated that *correct_x86_emulation* means that a finite >>>>>>>>>>>>> string of x86 instructions is emulated according to the >>>>>>>>>>>>> semantics of the x86 language beginning with the first bytes >>>>>>>>>>>>> of this string.
the discipline to stay within the precisely designated scope of the
exact words that I am saying.
When HHH is an x86 emulation based termination analyzer then each
DDD *correctly_emulated_by* any HHH that it calls cannot possibly
return no matter what this HHH does.
first one aborts then none of them can possibly abort because they all
have the exact same code.
details. It is utterly impossible for any of them besides the outermost
one to abort because it aborts before any of the rest of them see their
abort criteria has been met.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 715 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 00:15:13 |
| Calls: | 12,097 |
| Calls today: | 5 |
| Files: | 15,003 |
| Messages: | 6,517,857 |