On 10/2/2024 5:48 PM, Richard Damon wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know anything >>>>>>>> anyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an infinite >>>>>>>> loop
of calls unless there is some form of termination condition
built into
`HHH`.
Without such a condition, `HHH` would never return, resulting in >>>>>>>> non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have >>>>>>>> specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls
correctly:
- **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>> exhaust the stack memory, leading to a stack overflow error.
[Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may lead >>>>>>>> to an
incorrect conclusion about halting, misrepresenting itself as
either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should implement: >>>>>>>> - **Guard Clauses**: Checks at the beginning of the function to >>>>>>>> prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being
analyzed,
allowing `HHH` to recognize if it's being invoked with itself
and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself
without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>> overflow. A robust design would include checks to prevent
self-invocation, ensuring the termination analyzer can handle all >>>>>>>> cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited as an >>>>>> authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it.
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only what
matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite
execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when run?
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
When two execution traces differ and one expects the same behavior
this is the same as analogous to the insanity of doing the exact
same thing and expecting different results. It is merely the other
side. Doing an entirely different thing and expecting the same
results is also quite crazy.
On 10/2/2024 5:48 PM, Richard Damon wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know anything >>>>>>>> anyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an infinite loop >>>>>>>> of calls unless there is some form of termination condition built into >>>>>>>> `HHH`.
Without such a condition, `HHH` would never return, resulting in non- >>>>>>>> termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have >>>>>>>> specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls correctly: >>>>>>>> - **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>> exhaust the stack memory, leading to a stack overflow error.
[Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may lead to an >>>>>>>> incorrect conclusion about halting, misrepresenting itself as either >>>>>>>> halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should implement: >>>>>>>> - **Guard Clauses**: Checks at the beginning of the function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being analyzed, >>>>>>>> allowing `HHH` to recognize if it's being invoked with itself and act >>>>>>>> accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself without >>>>>>>> proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>> overflow. A robust design would include checks to prevent
self-invocation, ensuring the termination analyzer can handle all >>>>>>>> cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited as an >>>>>> authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it.
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only what
matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite
execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when run?
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
On 10/3/2024 7:15 AM, Mikko wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know >>>>>>>>>> anythinganyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an
infinite loop
of calls unless there is some form of termination condition >>>>>>>>>> built into
`HHH`.
Without such a condition, `HHH` would never return, resulting >>>>>>>>>> in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have >>>>>>>>>> specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls >>>>>>>>>> correctly:
- **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>>>> exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may >>>>>>>>>> lead to an
incorrect conclusion about halting, misrepresenting itself as >>>>>>>>>> either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should implement: >>>>>>>>>> - **Guard Clauses**: Checks at the beginning of the function >>>>>>>>>> to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being >>>>>>>>>> analyzed,
allowing `HHH` to recognize if it's being invoked with itself >>>>>>>>>> and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself >>>>>>>>>> without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>> overflow. A robust design would include checks to prevent
self-invocation, ensuring the termination analyzer can handle all >>>>>>>>>> cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited >>>>>>>> as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only what >>>>>> matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite
execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when
run?
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD takes no input
its behavour is always the same. What does "make a difference" mean
in this context?
The behavior of the directly executed DDD is essentially the
behavior of what would otherwise be infinite recursion except
that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated
by the same emulator that it calls where HHH cannot rely on DDD
being aborted by any other process than itself.
Do an entirely different thing and expecting the same results
is just as insane as doing the same thing and expecting different results.
On 10/3/2024 6:16 AM, Richard Damon wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 10/2/24 10:09 PM, olcott wrote:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know >>>>>>>>>> anythinganyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an
infinite loop
of calls unless there is some form of termination condition >>>>>>>>>> built into
`HHH`.
Without such a condition, `HHH` would never return, resulting >>>>>>>>>> in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have >>>>>>>>>> specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls >>>>>>>>>> correctly:
- **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>>>> exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may >>>>>>>>>> lead to an
incorrect conclusion about halting, misrepresenting itself as >>>>>>>>>> either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should implement: >>>>>>>>>> - **Guard Clauses**: Checks at the beginning of the function >>>>>>>>>> to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being >>>>>>>>>> analyzed,
allowing `HHH` to recognize if it's being invoked with itself >>>>>>>>>> and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself >>>>>>>>>> without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>> overflow. A robust design would include checks to prevent
self-invocation, ensuring the termination analyzer can handle all >>>>>>>>>> cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited >>>>>>>> as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only what >>>>>> matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite
execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when
run?
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
When two execution traces differ and one expects the same behavior
this is the same as analogous to the insanity of doing the exact
same thing and expecting different results. It is merely the other
side. Doing an entirely different thing and expecting the same
results is also quite crazy.
No, YOU don't seem to understand that the while the pathological
relationship DOES affect the behavior of DDD, it doesn't mean that the
"correct simulation" of DDD (by anybody) will differ from the actual
behavior of DDD.
If the emulator ignores rather than emulates this
pathological relationship when the x86 code specifies
this pathological relationship then it is the same
kind of damned liar that you are.
On 10/3/2024 7:15 AM, Mikko wrote:Naturally, you need an outside proof for that.
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know >>>>>>>>>> anything anyway.
*You can continue this conversation with ChatGPT*I’ll leave that to you.
In the case of their evaluation of my work they are correct.No, it will tell you something that matches the words you told it. >>>>>> You don't seem to understand what Large Language Models are.You feed it your objections.Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited as >>>>>>>> an authority (fallacious anyway).
It will tell you how and why you are wrong.
You seem to forget that LLM know nothing of the "truth", only what >>>>>> matches their training data.
They are know to be liars, just like you.
And what does ChatGPT „think”?You guys try to pretend that the pathological relationship between HHH*Try this yourself*Try asking it
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite
execution of DDD?
Why is it ok for HHH to say that DDD doesn't halt when it will when
run?
and DDD does not make any difference to the behavior of DDD knowing
full well that it does make a difference.
Simulation is doing the same thing though.The behaviour of DDD is what DDD does if executed. As DDD takes noThe behavior of the directly executed DDD is essentially the behavior of
input its behavour is always the same. What does "make a difference"
mean in this context?
what would otherwise be infinite recursion except that the second
recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated by the
same emulator that it calls where HHH cannot rely on DDD being aborted
by any other process than itself.
Do an entirely different thing and expecting the same results is just as insane as doing the same thing and expecting different results.
On 10/3/2024 7:15 AM, Mikko wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know anythinganyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an infinite loop
of calls unless there is some form of termination condition built into
`HHH`.
Without such a condition, `HHH` would never return, resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have >>>>>>>>>> specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls correctly:
- **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>>>> exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may lead to an
incorrect conclusion about halting, misrepresenting itself as either >>>>>>>>>> halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should implement: >>>>>>>>>> - **Guard Clauses**: Checks at the beginning of the function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being analyzed, >>>>>>>>>> allowing `HHH` to recognize if it's being invoked with itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself without >>>>>>>>>> proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>> overflow. A robust design would include checks to prevent
self-invocation, ensuring the termination analyzer can handle all >>>>>>>>>> cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited as an >>>>>>>> authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only what >>>>>> matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite
execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when run? >>>>
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD takes no input
its behavour is always the same. What does "make a difference" mean
in this context?
The behavior of the directly executed DDD is essentially the
behavior of what would otherwise be infinite recursion except
that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated
by the same emulator that it calls where HHH cannot rely on DDD
being aborted by any other process than itself.
Do an entirely different thing and expecting the same results
is just as insane as doing the same thing and expecting different results.
On 10/3/2024 8:17 PM, Richard Damon wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 10/3/24 6:46 PM, olcott wrote:
On 10/3/2024 6:16 AM, Richard Damon wrote:
On 10/2/24 10:09 PM, olcott wrote:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know >>>>>>>>>>>> anythinganyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an >>>>>>>>>>>> infinite loop
of calls unless there is some form of termination condition >>>>>>>>>>>> built into
`HHH`.
Without such a condition, `HHH` would never return,
resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to >>>>>>>>>>>> have
specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls >>>>>>>>>>>> correctly:
- **Stack Overflow**: Continuous self-invocation will
eventually
exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may >>>>>>>>>>>> lead to an
incorrect conclusion about halting, misrepresenting itself >>>>>>>>>>>> as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should >>>>>>>>>>>> implement:
- **Guard Clauses**: Checks at the beginning of the function >>>>>>>>>>>> to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being >>>>>>>>>>>> analyzed,
allowing `HHH` to recognize if it's being invoked with >>>>>>>>>>>> itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself >>>>>>>>>>>> without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>>>> overflow. A robust design would include checks to prevent >>>>>>>>>>>> self-invocation, ensuring the termination analyzer can >>>>>>>>>>>> handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited >>>>>>>>>> as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>>>
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only
what matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the
infinite execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will
when run?
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
When two execution traces differ and one expects the same behavior
this is the same as analogous to the insanity of doing the exact
same thing and expecting different results. It is merely the other
side. Doing an entirely different thing and expecting the same
results is also quite crazy.
No, YOU don't seem to understand that the while the pathological
relationship DOES affect the behavior of DDD, it doesn't mean that
the "correct simulation" of DDD (by anybody) will differ from the
actual behavior of DDD.
If the emulator ignores rather than emulates this
pathological relationship when the x86 code specifies
this pathological relationship then it is the same
kind of damned liar that you are.
So, what did it actually EMULATE that differed?
The directly executed DDD() depends on HHH aborting what
would otherwise be its own infinite recursive emulation.
Mike is the only one smart enough to understand these things
and he refuses to, providing double-talk instead of reasoning.
On 10/4/2024 5:50 AM, Richard Damon wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 10/3/24 10:48 PM, olcott wrote:
On 10/3/2024 8:17 PM, Richard Damon wrote:
On 10/3/24 6:46 PM, olcott wrote:
On 10/3/2024 6:16 AM, Richard Damon wrote:
On 10/2/24 10:09 PM, olcott wrote:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/It sounds like it’s trained on your spam. LLMs don’t know >>>>>>>>>>>>>> anything
share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
anyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an >>>>>>>>>>>>>> infinite loop
of calls unless there is some form of termination
condition built into
`HHH`.
Without such a condition, `HHH` would never return, >>>>>>>>>>>>>> resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need >>>>>>>>>>>>>> to have
specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential >>>>>>>>>>>>>> calls correctly:
- **Stack Overflow**: Continuous self-invocation will >>>>>>>>>>>>>> eventually
exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may >>>>>>>>>>>>>> lead to an
incorrect conclusion about halting, misrepresenting itself >>>>>>>>>>>>>> as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers** >>>>>>>>>>>>>> To avoid these pitfalls, a termination analyzer should >>>>>>>>>>>>>> implement:
- **Guard Clauses**: Checks at the beginning of the >>>>>>>>>>>>>> function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being >>>>>>>>>>>>>> analyzed,
allowing `HHH` to recognize if it's being invoked with >>>>>>>>>>>>>> itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate >>>>>>>>>>>>>> itself without
proper safeguards,
it risks falling into an infinite recursion or causing a >>>>>>>>>>>>>> stack
overflow. A robust design would include checks to prevent >>>>>>>>>>>>>> self-invocation, ensuring the termination analyzer can >>>>>>>>>>>>>> handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question: >>>>>>>>>>>>> Is H a Halt Decider for D?You should feed it our objections.
If you believe in it only when you prompt it, it is not >>>>>>>>>>>> suited as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told >>>>>>>>>> it.
You don't seem to understand what Large Language Models are. >>>>>>>>>>
You seem to forget that LLM know nothing of the "truth", only >>>>>>>>>> what matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct. >>>>>>>>>
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>
Does HHH have to abort its emulation of DDD to prevent the
infinite execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will >>>>>>>> when run?
You guys try to pretend that the pathological relationship between >>>>>>> HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
When two execution traces differ and one expects the same behavior >>>>>>> this is the same as analogous to the insanity of doing the exact >>>>>>> same thing and expecting different results. It is merely the other >>>>>>> side. Doing an entirely different thing and expecting the same
results is also quite crazy.
No, YOU don't seem to understand that the while the pathological
relationship DOES affect the behavior of DDD, it doesn't mean that >>>>>> the "correct simulation" of DDD (by anybody) will differ from the
actual behavior of DDD.
If the emulator ignores rather than emulates this
pathological relationship when the x86 code specifies
this pathological relationship then it is the same
kind of damned liar that you are.
So, what did it actually EMULATE that differed?
The directly executed DDD() depends on HHH aborting what
would otherwise be its own infinite recursive emulation.
So? Since that is what the code of that HHH does, that is what DDD does.
When DDD is executed first it has provably different
halting behavior than when DDD is emulated by the same
emulator that it calls.
Everyone besides Mike is simply not bright enough
to see this. Mike can see this yet refuses to admit
that he sees this.
On 10/4/2024 4:05 AM, Mikko wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-03 21:01:51 +0000, olcott said:
On 10/3/2024 7:15 AM, Mikko wrote:
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott:
On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know anythinganyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an infinite loop
of calls unless there is some form of termination condition built into
`HHH`.
Without such a condition, `HHH` would never return, resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have >>>>>>>>>>>> specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls correctly:
- **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>>>>>> exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may lead to an
incorrect conclusion about halting, misrepresenting itself as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers**
To avoid these pitfalls, a termination analyzer should implement: >>>>>>>>>>>> - **Guard Clauses**: Checks at the beginning of the function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being analyzed,
allowing `HHH` to recognize if it's being invoked with itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>>>> overflow. A robust design would include checks to prevent >>>>>>>>>>>> self-invocation, ensuring the termination analyzer can handle all >>>>>>>>>>>> cases, including its own function,
gracefully.
Click on the link and see how it answers this question:You should feed it our objections.
Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited as an >>>>>>>>>> authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>>>
You don't seem to understand what Large Language Models are.
You seem to forget that LLM know nothing of the "truth", only what >>>>>>>> matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct.
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
Does HHH have to abort its emulation of DDD to prevent the infinite >>>>>>> execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when run? >>>>>>
You guys try to pretend that the pathological relationship between
HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD takes no input >>>> its behavour is always the same. What does "make a difference" mean
in this context?
The behavior of the directly executed DDD is essentially the
behavior of what would otherwise be infinite recursion except
that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated
by the same emulator that it calls where HHH cannot rely on DDD
being aborted by any other process than itself.
So the behaviour of DDD "correctly" emulated is not the behaviour
of DDD.
Directly executed DDD can rely on having its second invocation
aborted by HHH is different behavior than DDD emulated by HHH
according to the behavior specified by x86 the machine code of
DDD and HHH where HHH cannot rely on DDD having already been
aborted by anything else.
On 10/4/2024 5:43 PM, Richard Damon wrote:oq=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 10/4/24 1:14 PM, olcott wrote:
On 10/4/2024 5:50 AM, Richard Damon wrote:
On 10/3/24 10:48 PM, olcott wrote:
On 10/3/2024 8:17 PM, Richard Damon wrote:
On 10/3/24 6:46 PM, olcott wrote:
On 10/3/2024 6:16 AM, Richard Damon wrote:
On 10/2/24 10:09 PM, olcott wrote:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 10/1/2024 8:09 AM, joes wrote:
q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
You should feed it our objections.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/It sounds like it’s trained on your spam. LLMs don’t >>>>>>>>>>>>>>>> know anything
share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
anyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an >>>>>>>>>>>>>>>> infinite loop
of calls unless there is some form of termination >>>>>>>>>>>>>>>> condition built into
`HHH`.
Without such a condition, `HHH` would never return, >>>>>>>>>>>>>>>> resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would >>>>>>>>>>>>>>>> need to have
specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT* >>>>>>>>>>>>>> I’ll leave that to you.
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential >>>>>>>>>>>>>>>> calls correctly:
- **Stack Overflow**: Continuous self-invocation will >>>>>>>>>>>>>>>> eventually
exhaust the stack memory, leading to a stack overflow >>>>>>>>>>>>>>>> error.
[Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it >>>>>>>>>>>>>>>> may lead to an
incorrect conclusion about halting, misrepresenting >>>>>>>>>>>>>>>> itself as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers** >>>>>>>>>>>>>>>> To avoid these pitfalls, a termination analyzer should >>>>>>>>>>>>>>>> implement:
- **Guard Clauses**: Checks at the beginning of the >>>>>>>>>>>>>>>> function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions >>>>>>>>>>>>>>>> being analyzed,
allowing `HHH` to recognize if it's being invoked with >>>>>>>>>>>>>>>> itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate >>>>>>>>>>>>>>>> itself without
proper safeguards,
it risks falling into an infinite recursion or causing a >>>>>>>>>>>>>>>> stack
overflow. A robust design would include checks to prevent >>>>>>>>>>>>>>>> self-invocation, ensuring the termination analyzer can >>>>>>>>>>>>>>>> handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question: >>>>>>>>>>>>>>> Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not >>>>>>>>>>>>>> suited as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you >>>>>>>>>>>> told it.
You don't seem to understand what Large Language Models are. >>>>>>>>>>>>
You seem to forget that LLM know nothing of the "truth", >>>>>>>>>>>> only what matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct. >>>>>>>>>>>
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>
Does HHH have to abort its emulation of DDD to prevent the >>>>>>>>>>> infinite execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will >>>>>>>>>> when run?
You guys try to pretend that the pathological relationship between >>>>>>>>> HHH and DDD does not make any difference to the behavior of DDD >>>>>>>>> knowing full well that it does make a difference.
When two execution traces differ and one expects the same behavior >>>>>>>>> this is the same as analogous to the insanity of doing the exact >>>>>>>>> same thing and expecting different results. It is merely the other >>>>>>>>> side. Doing an entirely different thing and expecting the same >>>>>>>>> results is also quite crazy.
No, YOU don't seem to understand that the while the pathological >>>>>>>> relationship DOES affect the behavior of DDD, it doesn't mean
that the "correct simulation" of DDD (by anybody) will differ
from the actual behavior of DDD.
If the emulator ignores rather than emulates this
pathological relationship when the x86 code specifies
this pathological relationship then it is the same
kind of damned liar that you are.
So, what did it actually EMULATE that differed?
The directly executed DDD() depends on HHH aborting what
would otherwise be its own infinite recursive emulation.
So? Since that is what the code of that HHH does, that is what DDD
does.
When DDD is executed first it has provably different
halting behavior than when DDD is emulated by the same
emulator that it calls.
NOPE.
Just prove you LIE.
The problem is that the emulator that it calls just can not correctly
emulate it, as that would require finding an N that is greater than N+1
You cannot possibly provide actual coherent reasoning
to show this because you defined "correct" incorrectly..
That you are unable to understand that it is easily conclusively
proven (below) that the emulated HHH does emulate its DDD correctly
is why your double-talk gibberish rebuttal fails.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] 33c0 xor eax,eax
[000021b2] 5d pop ebp
[000021b3] c3 ret
Size in bytes:(0034) [000021b3]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00002192][00103820][00000000] 55 push ebp ; Begin main()
[00002193][00103820][00000000] 8bec mov ebp,esp ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4
Begin Local Halt Decider Simulation Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55 push ebp ; housekeeping
[00002173][001138bc][001138c0] 8bec mov ebp,esp ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
// emulated HHH emulating DDD
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55 push ebp ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec mov ebp,esp ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[0000219f][00103820][00000000] 83c404 add esp,+04 [000021a2][0010381c][00000000] 50 push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408 add esp,+08 [000021b0][00103820][00000000] 33c0 xor eax,eax [000021b2][00103824][00000018] 5d pop ebp [000021b3][00103828][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages
On 10/5/2024 8:27 AM, Richard Damon wrote:
On 10/5/24 8:21 AM, olcott wrote:
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily conclusively
proven (below) that the emulated HHH does emulate its DDD correctly
is why your double-talk gibberish rebuttal fails.
Nope, the trace actually proves the opposite.
The following execution trace conclusively proves that
HHH emulated by itself does emulate the first four lines
of DDD correctly.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] 33c0 xor eax,eax
[000021b2] 5d pop ebp
[000021b3] c3 ret
Size in bytes:(0034) [000021b3]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00002192][00103820][00000000] 55 push ebp ; Begin main()
[00002193][00103820][00000000] 8bec mov ebp,esp ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4
Begin Local Halt Decider Simulation Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55 push ebp ; housekeeping
[00002173][001138bc][001138c0] 8bec mov ebp,esp ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
// emulated HHH emulating DDD
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55 push ebp ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec mov ebp,esp ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[0000219f][00103820][00000000] 83c404 add esp,+04 [000021a2][0010381c][00000000] 50 push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408 add esp,+08 [000021b0][00103820][00000000] 33c0 xor eax,eax [000021b2][00103824][00000018] 5d pop ebp [000021b3][00103828][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily conclusively
proven (below) that the emulated HHH does emulate its DDD correctly
is why your double-talk gibberish rebuttal fails.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] 33c0 xor eax,eax
[000021b2] 5d pop ebp
[000021b3] c3 ret
Size in bytes:(0034) [000021b3]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00002192][00103820][00000000] 55 push ebp ; Begin main()
[00002193][00103820][00000000] 8bec mov ebp,esp ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4
Begin Local Halt Decider Simulation Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55 push ebp ; housekeeping
[00002173][001138bc][001138c0] 8bec mov ebp,esp ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
// emulated HHH emulating DDD
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55 push ebp ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec mov ebp,esp ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[0000219f][00103820][00000000] 83c404 add esp,+04 [000021a2][0010381c][00000000] 50 push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408 add esp,+08 [000021b0][00103820][00000000] 33c0 xor eax,eax [000021b2][00103824][00000018] 5d pop ebp [000021b3][00103828][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages
That you are unable to understand that it is easily conclusively
proven (below) that the emulated HHH does emulate its DDD correctly
is why your double-talk gibberish rebuttal fails.
But then why does it get the right answer?
Note, edited traces, as you provide below, just prove you are trying
to get away wioth something. and don't prove anything,
Even if I didn't actually have any x86 emulator and did
simply fake the traces this still conclusively proves
that HHH emulated by itself does emulate DDD correctly.
Because I have provided the source-code for many years
it is ridiculously stupid for you to imply that the traces
are faked. I even tell you which compiler to use.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
https://github.com/plolcott/x86utm
On 10/5/2024 8:38 AM, Richard Damon wrote:
On 10/5/24 9:34 AM, olcott wrote:
On 10/5/2024 8:27 AM, Richard Damon wrote:
On 10/5/24 8:21 AM, olcott wrote:
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily conclusively
proven (below) that the emulated HHH does emulate its DDD correctly
is why your double-talk gibberish rebuttal fails.
Nope, the trace actually proves the opposite.
The following execution trace conclusively proves that
HHH emulated by itself does emulate the first four lines
of DDD correctly.
Right, and then makes the error of PRESUMEING INCORREDTLY that
HHH(DDD) will not return,
That this is over-your-head really is not my mistake.
*DDD emulated by HHH cannot possibly return*
Mike is the only one smart enough to understand this
and he refuses to admit it.
That you have a tantrum over your own mistake shows
that you are woefully lacking in professional decorum.
_DDD()
[00002172] 55 push ebp ; housekeeping
[00002173] 8bec mov ebp,esp ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404 add esp,+04
[00002182] 5d pop ebp
[00002183] c3 ret
Size in bytes:(0018) [00002183]
_main()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404 add esp,+04
[000021a2] 50 push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408 add esp,+08
[000021b0] 33c0 xor eax,eax
[000021b2] 5d pop ebp
[000021b3] c3 ret
Size in bytes:(0034) [000021b3]
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= ============= [00002192][00103820][00000000] 55 push ebp ; Begin main()
[00002193][00103820][00000000] 8bec mov ebp,esp ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD [0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:1038c4
Begin Local Halt Decider Simulation Execution Trace Stored at:1138cc [00002172][001138bc][001138c0] 55 push ebp ; housekeeping
[00002173][001138bc][001138c0] 8bec mov ebp,esp ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD [0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
// emulated HHH emulating DDD
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55 push ebp ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec mov ebp,esp ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD [0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
[0000219f][00103820][00000000] 83c404 add esp,+04 [000021a2][0010381c][00000000] 50 push eax [000021a3][00103818][00000743] 6843070000 push 00000743 [000021a8][00103818][00000743] e8b5e5ffff call 00000762
Input_Halts = 0
[000021ad][00103820][00000000] 83c408 add esp,+08 [000021b0][00103820][00000000] 33c0 xor eax,eax [000021b2][00103824][00000018] 5d pop ebp [000021b3][00103828][00000000] c3 ret
Number of Instructions Executed(10069) == 150 Pages
On 10/5/2024 9:46 PM, Richard Damon wrote:
On 10/5/24 9:43 AM, olcott wrote:
On 10/5/2024 8:38 AM, Richard Damon wrote:
On 10/5/24 9:34 AM, olcott wrote:
On 10/5/2024 8:27 AM, Richard Damon wrote:
On 10/5/24 8:21 AM, olcott wrote:
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily conclusively >>>>>>> proven (below) that the emulated HHH does emulate its DDD correctly >>>>>>> is why your double-talk gibberish rebuttal fails.
Nope, the trace actually proves the opposite.
The following execution trace conclusively proves that
HHH emulated by itself does emulate the first four lines
of DDD correctly.
Right, and then makes the error of PRESUMEING INCORREDTLY that
HHH(DDD) will not return,
That this is over-your-head really is not my mistake.
*DDD emulated by HHH cannot possibly return*
No, it is beyond YOUR head that the fact that HHH does abort its
emulation means its doesn't show if the HHH that it was emulating will
return on not.
This is simply over your head.
The infinite set of DDD emulated by HHH
never returns no matter what its corresponding HHH does.
*Woefully insufficient professional decorum ruins your credibility*
On 10/5/2024 10:22 PM, Richard Damon wrote:
On 10/5/24 10:58 PM, olcott wrote:
On 10/5/2024 9:46 PM, Richard Damon wrote:
On 10/5/24 9:43 AM, olcott wrote:
On 10/5/2024 8:38 AM, Richard Damon wrote:
On 10/5/24 9:34 AM, olcott wrote:
On 10/5/2024 8:27 AM, Richard Damon wrote:
On 10/5/24 8:21 AM, olcott wrote:
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily conclusively >>>>>>>>> proven (below) that the emulated HHH does emulate its DDD
correctly
is why your double-talk gibberish rebuttal fails.
Nope, the trace actually proves the opposite.
The following execution trace conclusively proves that
HHH emulated by itself does emulate the first four lines
of DDD correctly.
Right, and then makes the error of PRESUMEING INCORREDTLY that
HHH(DDD) will not return,
That this is over-your-head really is not my mistake.
*DDD emulated by HHH cannot possibly return*
No, it is beyond YOUR head that the fact that HHH does abort its
emulation means its doesn't show if the HHH that it was emulating
will return on not.
This is simply over your head.
The infinite set of DDD emulated by HHH
never returns no matter what its corresponding HHH does.
No, that is just a false statement based on you changing the meaning
of the words.
EVERY DDD that calls an HHH(DDD) that ever returns an answer will halt.
No DDD emulated by any corresponding HHH ever returns
and the HHH that emulates it does return an answer
corresponding to this behavior of this emulated DDD.
On 10/5/2024 10:51 PM, Richard Damon wrote:
On 10/5/24 11:39 PM, olcott wrote:
On 10/5/2024 10:22 PM, Richard Damon wrote:
On 10/5/24 10:58 PM, olcott wrote:
On 10/5/2024 9:46 PM, Richard Damon wrote:
On 10/5/24 9:43 AM, olcott wrote:
On 10/5/2024 8:38 AM, Richard Damon wrote:
On 10/5/24 9:34 AM, olcott wrote:
On 10/5/2024 8:27 AM, Richard Damon wrote:
On 10/5/24 8:21 AM, olcott wrote:
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily conclusively >>>>>>>>>>> proven (below) that the emulated HHH does emulate its DDD >>>>>>>>>>> correctly
is why your double-talk gibberish rebuttal fails.
Nope, the trace actually proves the opposite.
The following execution trace conclusively proves that
HHH emulated by itself does emulate the first four lines
of DDD correctly.
Right, and then makes the error of PRESUMEING INCORREDTLY that >>>>>>>> HHH(DDD) will not return,
That this is over-your-head really is not my mistake.
*DDD emulated by HHH cannot possibly return*
No, it is beyond YOUR head that the fact that HHH does abort its
emulation means its doesn't show if the HHH that it was emulating
will return on not.
This is simply over your head.
The infinite set of DDD emulated by HHH
never returns no matter what its corresponding HHH does.
No, that is just a false statement based on you changing the meaning
of the words.
EVERY DDD that calls an HHH(DDD) that ever returns an answer will halt. >>>>
No DDD emulated by any corresponding HHH ever returns
and the HHH that emulates it does return an answer
corresponding to this behavior of this emulated DDD.
That is a lie based on your misunderstanding of the meaning of the words.
*No DDD emulated by any corresponding HHH ever returns*
Until you understand this point you remain clueless.
On 10/5/2024 3:20 AM, Mikko wrote:Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-04 14:54:06 +0000, olcott said:
On 10/4/2024 4:05 AM, Mikko wrote:
On 2024-10-03 21:01:51 +0000, olcott said:
On 10/3/2024 7:15 AM, Mikko wrote:
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott:
On 10/1/2024 8:09 AM, joes wrote:q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&oq=
Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
I’ll leave that to you.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/ share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t know anythinganyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an infinite loop
of calls unless there is some form of termination condition built into
`HHH`.
Without such a condition, `HHH` would never return, resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have
specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT*
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls correctly:
- **Stack Overflow**: Continuous self-invocation will eventually >>>>>>>>>>>>>> exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may lead to an
incorrect conclusion about halting, misrepresenting itself as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers** >>>>>>>>>>>>>> To avoid these pitfalls, a termination analyzer should implement:
- **Guard Clauses**: Checks at the beginning of the function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being analyzed,
allowing `HHH` to recognize if it's being invoked with itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>>>>>> overflow. A robust design would include checks to prevent >>>>>>>>>>>>>> self-invocation, ensuring the termination analyzer can handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question: >>>>>>>>>>>>> Is H a Halt Decider for D?You should feed it our objections.
If you believe in it only when you prompt it, it is not suited as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>>>>>
You don't seem to understand what Large Language Models are. >>>>>>>>>>
You seem to forget that LLM know nothing of the "truth", only what >>>>>>>>>> matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct. >>>>>>>>>
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>
Does HHH have to abort its emulation of DDD to prevent the infinite >>>>>>>>> execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when run?
You guys try to pretend that the pathological relationship between >>>>>>> HHH and DDD does not make any difference to the behavior of DDD
knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD takes no input >>>>>> its behavour is always the same. What does "make a difference" mean >>>>>> in this context?
The behavior of the directly executed DDD is essentially the
behavior of what would otherwise be infinite recursion except
that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated
by the same emulator that it calls where HHH cannot rely on DDD
being aborted by any other process than itself.
So the behaviour of DDD "correctly" emulated is not the behaviour
of DDD.
Directly executed DDD can rely on having its second invocation
aborted by HHH is different behavior than DDD emulated by HHH
according to the behavior specified by x86 the machine code of
DDD and HHH where HHH cannot rely on DDD having already been
aborted by anything else.
DDD does not "rely" on anything. It simply is a specification of
a behaviour.
When DDD is executed before HHH its behavior its different
than when DDD is emulated by HHH. This is easy to see by
anyone that is not totally clueless about the x86 language.
If HHH(DDD) returns 0, as your claimed correct one does, then DDD will
return and that answer is wrong.
On 10/6/2024 5:36 AM, Mikko wrote:oq=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-05 12:12:43 +0000, olcott said:
On 10/5/2024 3:20 AM, Mikko wrote:
On 2024-10-04 14:54:06 +0000, olcott said:
On 10/4/2024 4:05 AM, Mikko wrote:
On 2024-10-03 21:01:51 +0000, olcott said:
On 10/3/2024 7:15 AM, Mikko wrote:
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 10/1/2024 8:09 AM, joes wrote:
q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
You should feed it our objections.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/It sounds like it’s trained on your spam. LLMs don’t >>>>>>>>>>>>>>>> know anything
share/66fbec5c-7b10-8011-9ce6-3c26424cb21c
anyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an >>>>>>>>>>>>>>>> infinite loop
of calls unless there is some form of termination >>>>>>>>>>>>>>>> condition built into
`HHH`.
Without such a condition, `HHH` would never return, >>>>>>>>>>>>>>>> resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would >>>>>>>>>>>>>>>> need to have
specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT* >>>>>>>>>>>>>> I’ll leave that to you.
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential >>>>>>>>>>>>>>>> calls correctly:
- **Stack Overflow**: Continuous self-invocation will >>>>>>>>>>>>>>>> eventually
exhaust the stack memory, leading to a stack overflow >>>>>>>>>>>>>>>> error.
[Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it >>>>>>>>>>>>>>>> may lead to an
incorrect conclusion about halting, misrepresenting >>>>>>>>>>>>>>>> itself as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers** >>>>>>>>>>>>>>>> To avoid these pitfalls, a termination analyzer should >>>>>>>>>>>>>>>> implement:
- **Guard Clauses**: Checks at the beginning of the >>>>>>>>>>>>>>>> function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions >>>>>>>>>>>>>>>> being analyzed,
allowing `HHH` to recognize if it's being invoked with >>>>>>>>>>>>>>>> itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate >>>>>>>>>>>>>>>> itself without
proper safeguards,
it risks falling into an infinite recursion or causing a >>>>>>>>>>>>>>>> stack
overflow. A robust design would include checks to prevent >>>>>>>>>>>>>>>> self-invocation, ensuring the termination analyzer can >>>>>>>>>>>>>>>> handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question: >>>>>>>>>>>>>>> Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not >>>>>>>>>>>>>> suited as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you >>>>>>>>>>>> told it.
You don't seem to understand what Large Language Models are. >>>>>>>>>>>>
You seem to forget that LLM know nothing of the "truth", >>>>>>>>>>>> only what matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct. >>>>>>>>>>>
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>
Does HHH have to abort its emulation of DDD to prevent the >>>>>>>>>>> infinite execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will >>>>>>>>>> when run?
You guys try to pretend that the pathological relationship between >>>>>>>>> HHH and DDD does not make any difference to the behavior of DDD >>>>>>>>> knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD takes >>>>>>>> no input
its behavour is always the same. What does "make a difference" mean >>>>>>>> in this context?
The behavior of the directly executed DDD is essentially the
behavior of what would otherwise be infinite recursion except
that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated
by the same emulator that it calls where HHH cannot rely on DDD
being aborted by any other process than itself.
So the behaviour of DDD "correctly" emulated is not the behaviour
of DDD.
Directly executed DDD can rely on having its second invocation
aborted by HHH is different behavior than DDD emulated by HHH
according to the behavior specified by x86 the machine code of
DDD and HHH where HHH cannot rely on DDD having already been
aborted by anything else.
DDD does not "rely" on anything. It simply is a specification of
a behaviour.
When DDD is executed before HHH its behavior its different
than when DDD is emulated by HHH. This is easy to see by
anyone that is not totally clueless about the x86 language.
The former is the behaviour of DDD. The latter is someting else though
similar to some extent. That something and someting else are different
is no news.
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
On 10/6/2024 6:13 AM, Richard Damon wrote:
On 10/5/24 11:54 PM, olcott wrote:
On 10/5/2024 10:51 PM, Richard Damon wrote:
On 10/5/24 11:39 PM, olcott wrote:
On 10/5/2024 10:22 PM, Richard Damon wrote:
On 10/5/24 10:58 PM, olcott wrote:
On 10/5/2024 9:46 PM, Richard Damon wrote:
On 10/5/24 9:43 AM, olcott wrote:
On 10/5/2024 8:38 AM, Richard Damon wrote:
On 10/5/24 9:34 AM, olcott wrote:
On 10/5/2024 8:27 AM, Richard Damon wrote:
On 10/5/24 8:21 AM, olcott wrote:
On 10/5/2024 5:58 AM, Richard Damon wrote:
On 10/4/24 9:53 PM, olcott wrote:
That you are unable to understand that it is easily
conclusively
proven (below) that the emulated HHH does emulate its DDD >>>>>>>>>>>>> correctly
is why your double-talk gibberish rebuttal fails.
Nope, the trace actually proves the opposite.
The following execution trace conclusively proves that
HHH emulated by itself does emulate the first four lines >>>>>>>>>>> of DDD correctly.
Right, and then makes the error of PRESUMEING INCORREDTLY that >>>>>>>>>> HHH(DDD) will not return,
That this is over-your-head really is not my mistake.
*DDD emulated by HHH cannot possibly return*
No, it is beyond YOUR head that the fact that HHH does abort its >>>>>>>> emulation means its doesn't show if the HHH that it was
emulating will return on not.
This is simply over your head.
The infinite set of DDD emulated by HHH
never returns no matter what its corresponding HHH does.
No, that is just a false statement based on you changing the
meaning of the words.
EVERY DDD that calls an HHH(DDD) that ever returns an answer will
halt.
No DDD emulated by any corresponding HHH ever returns
and the HHH that emulates it does return an answer
corresponding to this behavior of this emulated DDD.
That is a lie based on your misunderstanding of the meaning of the
words.
*No DDD emulated by any corresponding HHH ever returns*
Until you understand this point you remain clueless.
Which is just a LIE as I explained.
If HHH(DDD) returns 0, as your claimed correct one does, then DDD will
return and that answer is wrong.
I have proven that you are factually incorrect. This is
simply over-your-head. You seem to have the fallacy of
equivocation error in your reasoning. You might not even
know what that is. You may look it up and still not know
what that is.
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
On 10/6/2024 11:57 AM, Richard Damon wrote:
On 10/6/24 8:43 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
No, you have proven that you don't understand what is truth, but that
you just prefer to lie.
And a big part of this is that you just chose to not learn what the
word mean.
The only "rebuttal" to my paragraph is the fallacy of equivocation
error and you don't have a clue what this is.
"DDD emulated by each corresponding HHH" has a very precise meaning
that cannot be overcome by the fallacy of equivocation error.
On 10/6/2024 11:59 AM, Richard Damon wrote:
On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
No, the DDD return (if the HHH(DDD) gives an answer), just after the
HHH that emulated them gave up.
DDD emulated by each corresponding HHH that can possibly
exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Each of these HHH emulators that emulates the above DDD
and returns 0 correctly reports the above non-halting
behavior.
On 10/6/2024 12:29 PM, Richard Damon wrote:
On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote:
On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
No, the DDD return (if the HHH(DDD) gives an answer), just after the
HHH that emulated them gave up.
DDD emulated by each corresponding HHH that can possibly
exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above your head means
that the execution of DDD,
gets to ignore the fact that DDD was defined to
have a pathological relationship with HHH that
HHH cannot ignore.
Everyone that has been disagreeing with me insists
that a correct emulation of DDD by HHH must make
sure to ignore what the DDD/HHH code specifies.
On 10/6/2024 1:13 PM, Richard Damon wrote:
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote:
On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote:
On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
No, the DDD return (if the HHH(DDD) gives an answer), just after
the HHH that emulated them gave up.
DDD emulated by each corresponding HHH that can possibly
exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above your head means
that the execution of DDD,
gets to ignore the fact that DDD was defined to
have a pathological relationship with HHH that
HHH cannot ignore.
No, that isn't ignoring it, but taking into account that since HHH is
defined to be a specific program, it has specific behavior.
The behavior of the executed DDD after the emulated
DDD has already been aborted is different than the
behavior of the emulated DDD that must be aborted.
This is simply too difficult for you to understand.
On 10/6/2024 1:52 PM, Richard Damon wrote:
On 10/6/24 2:32 PM, olcott wrote:
On 10/6/2024 1:13 PM, Richard Damon wrote:
On 10/6/24 2:03 PM, olcott wrote:
On 10/6/2024 12:29 PM, Richard Damon wrote:
On 10/6/24 1:07 PM, olcott wrote:
On 10/6/2024 11:59 AM, Richard Damon wrote:
On 10/6/24 8:39 AM, olcott wrote:
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
No, the DDD return (if the HHH(DDD) gives an answer), just after >>>>>>>> the HHH that emulated them gave up.
DDD emulated by each corresponding HHH that can possibly
exist never returns.
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
DDD emulated by each corresponding HHH
Which, as you have been told but seems to be above your head means >>>>>> that the execution of DDD,
gets to ignore the fact that DDD was defined to
have a pathological relationship with HHH that
HHH cannot ignore.
No, that isn't ignoring it, but taking into account that since HHH
is defined to be a specific program, it has specific behavior.
The behavior of the executed DDD after the emulated
DDD has already been aborted is different than the
behavior of the emulated DDD that must be aborted.
Nope, it is the exact same code on the exact same data, and thus does
the exact same behavior.
The execution trace proves that the executed DDD has
different behavior that need not be aborted because
emulated DDD must be an is aborted.
No one can be stupid enough to think that
NEED NOT BE ABORTED is exactly the same as NEED NOT BE ABORTED
On 10/6/2024 5:36 AM, Mikko wrote:oq=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-05 12:12:43 +0000, olcott said:
On 10/5/2024 3:20 AM, Mikko wrote:
On 2024-10-04 14:54:06 +0000, olcott said:
On 10/4/2024 4:05 AM, Mikko wrote:
On 2024-10-03 21:01:51 +0000, olcott said:
On 10/3/2024 7:15 AM, Mikko wrote:
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott: >>>>>>>>>>>>>>> On 10/1/2024 8:09 AM, joes wrote:
q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=5&Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
You should feed it our objections.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz
https://chatgpt.com/ share/66fbec5c-7b10-8011-9ce6-3c26424cb21cIt sounds like it’s trained on your spam. LLMs don’t know anything
anyway.
I asked: „What happens when HHH tries to simulate itself?” >>>>>>>>>>>>>>>> ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH**
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates an infinite loop
of calls unless there is some form of termination condition built into
`HHH`.
Without such a condition, `HHH` would never return, resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would need to have
specific logic to prevent endless recursion:
[Not present.]*You can continue this conversation with ChatGPT* >>>>>>>>>>>>>> I’ll leave that to you.
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential calls correctly:
- **Stack Overflow**: Continuous self-invocation will eventually
exhaust the stack memory, leading to a stack overflow error. >>>>>>>>>>>>>>>> [Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it may lead to an
incorrect conclusion about halting, misrepresenting itself as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers** >>>>>>>>>>>>>>>> To avoid these pitfalls, a termination analyzer should implement:
- **Guard Clauses**: Checks at the beginning of the function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions being analyzed,
allowing `HHH` to recognize if it's being invoked with itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate itself without
proper safeguards,
it risks falling into an infinite recursion or causing a stack >>>>>>>>>>>>>>>> overflow. A robust design would include checks to prevent >>>>>>>>>>>>>>>> self-invocation, ensuring the termination analyzer can handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question: >>>>>>>>>>>>>>> Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not suited as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you told it. >>>>>>>>>>>>
You don't seem to understand what Large Language Models are. >>>>>>>>>>>>
You seem to forget that LLM know nothing of the "truth", only what >>>>>>>>>>>> matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct. >>>>>>>>>>>
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>
Does HHH have to abort its emulation of DDD to prevent the infinite >>>>>>>>>>> execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it will when run?
You guys try to pretend that the pathological relationship between >>>>>>>>> HHH and DDD does not make any difference to the behavior of DDD >>>>>>>>> knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD takes no input
its behavour is always the same. What does "make a difference" mean >>>>>>>> in this context?
The behavior of the directly executed DDD is essentially the
behavior of what would otherwise be infinite recursion except
that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated
by the same emulator that it calls where HHH cannot rely on DDD
being aborted by any other process than itself.
So the behaviour of DDD "correctly" emulated is not the behaviour
of DDD.
Directly executed DDD can rely on having its second invocation
aborted by HHH is different behavior than DDD emulated by HHH
according to the behavior specified by x86 the machine code of
DDD and HHH where HHH cannot rely on DDD having already been
aborted by anything else.
DDD does not "rely" on anything. It simply is a specification of
a behaviour.
When DDD is executed before HHH its behavior its different
than when DDD is emulated by HHH. This is easy to see by
anyone that is not totally clueless about the x86 language.
The former is the behaviour of DDD. The latter is someting else though
similar to some extent. That something and someting else are different
is no news.
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
On 10/7/2024 3:01 AM, Mikko wrote:5&oq=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-
On 2024-10-06 12:39:51 +0000, olcott said:
On 10/6/2024 5:36 AM, Mikko wrote:
On 2024-10-05 12:12:43 +0000, olcott said:
On 10/5/2024 3:20 AM, Mikko wrote:
On 2024-10-04 14:54:06 +0000, olcott said:
On 10/4/2024 4:05 AM, Mikko wrote:
On 2024-10-03 21:01:51 +0000, olcott said:
On 10/3/2024 7:15 AM, Mikko wrote:
On 2024-10-03 02:09:39 +0000, olcott said:
On 10/2/2024 5:48 PM, Richard Damon wrote:
On 10/2/24 10:39 AM, olcott wrote:
On 10/2/2024 6:08 AM, Richard Damon wrote:
On 10/1/24 7:26 PM, olcott wrote:
On 10/1/2024 12:58 PM, joes wrote:
Am Tue, 01 Oct 2024 12:31:41 -0500 schrieb olcott: >>>>>>>>>>>>>>>>> On 10/1/2024 8:09 AM, joes wrote:
q=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&sca_esv=889093c5cb21af9e&sca_upv=1&source=hp&ei=Muf7ZpOyMZHfwN4PwYL2gAc&iflsig=AL9hbdgAAAAAZvv1Qg04jNg2ze170z3a8BSGu8pA29Fj&ved=0ahUKEwiTk7zkk-2IAxWRL9AFHUGBHXAQ4dUDCBg&uact=Am Tue, 01 Oct 2024 07:39:18 -0500 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 10/1/2024 7:19 AM, olcott wrote:
https://www.google.com/search?
You should feed it our objections.AEC-AEBmAIAoAIAmAMAkgcAoAcA&sclient=gws-wiz >>>>>>>>>>>>>>>>>>> https://chatgpt.com/
share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>>>>>>>> It sounds like it’s trained on your spam. LLMs don’t >>>>>>>>>>>>>>>>>> know anythinganyway.
I asked: „What happens when HHH tries to simulate >>>>>>>>>>>>>>>>>> itself?”
ChatGPT: [my comments in brackets]
### 1. **Self-Invocation in HHH***You can continue this conversation with ChatGPT* >>>>>>>>>>>>>>>> I’ll leave that to you.
If `HHH` calls itself (i.e., `HHH(HHH)`), it creates >>>>>>>>>>>>>>>>>> an infinite loop
of calls unless there is some form of termination >>>>>>>>>>>>>>>>>> condition built into
`HHH`.
Without such a condition, `HHH` would never return, >>>>>>>>>>>>>>>>>> resulting in non-
termination.
[So not a decider.]
### 2. **Halting Criteria**
In a well-designed termination analyzer, `HHH` would >>>>>>>>>>>>>>>>>> need to have
specific logic to prevent endless recursion: >>>>>>>>>>>>>>>>
[Not present.]
### 3. **Practical Consequences**
If `HHH` lacks the ability to handle self-referential >>>>>>>>>>>>>>>>>> calls correctly:
- **Stack Overflow**: Continuous self-invocation will >>>>>>>>>>>>>>>>>> eventually
exhaust the stack memory, leading to a stack overflow >>>>>>>>>>>>>>>>>> error.
[Not considered in theory.]
- **Incorrect Results**: If not designed carefully, it >>>>>>>>>>>>>>>>>> may lead to an
incorrect conclusion about halting, misrepresenting >>>>>>>>>>>>>>>>>> itself as either
halting or non-halting.
### 4. **Best Practices for Termination Analyzers** >>>>>>>>>>>>>>>>>> To avoid these pitfalls, a termination analyzer should >>>>>>>>>>>>>>>>>> implement:
- **Guard Clauses**: Checks at the beginning of the >>>>>>>>>>>>>>>>>> function to prevent
unnecessary self-simulation.
- **State Management**: A way to track the functions >>>>>>>>>>>>>>>>>> being analyzed,
allowing `HHH` to recognize if it's being invoked with >>>>>>>>>>>>>>>>>> itself and act
accordingly.
### Conclusion In summary, if `HHH` tries to simulate >>>>>>>>>>>>>>>>>> itself without
proper safeguards,
it risks falling into an infinite recursion or causing >>>>>>>>>>>>>>>>>> a stack
overflow. A robust design would include checks to prevent >>>>>>>>>>>>>>>>>> self-invocation, ensuring the termination analyzer can >>>>>>>>>>>>>>>>>> handle all
cases, including its own function,
gracefully.
Click on the link and see how it answers this question: >>>>>>>>>>>>>>>>> Is H a Halt Decider for D?
If you believe in it only when you prompt it, it is not >>>>>>>>>>>>>>>> suited as an
authority (fallacious anyway).
You feed it your objections.
It will tell you how and why you are wrong.
No, it will tell you something that matches the words you >>>>>>>>>>>>>> told it.
You don't seem to understand what Large Language Models are. >>>>>>>>>>>>>>
You seem to forget that LLM know nothing of the "truth", >>>>>>>>>>>>>> only what matches their training data.
They are know to be liars, just like you.
In the case of their evaluation of my work they are correct. >>>>>>>>>>>>>
*Try this yourself*
https://chatgpt.com/share/66fbec5c-7b10-8011-9ce6-3c26424cb21c >>>>>>>>>>>>>
Does HHH have to abort its emulation of DDD to prevent the >>>>>>>>>>>>> infinite execution of DDD?
Try asking it
Why is it ok for HHH to say that DDD doesn't halt when it >>>>>>>>>>>> will when run?
You guys try to pretend that the pathological relationship >>>>>>>>>>> between
HHH and DDD does not make any difference to the behavior of DDD >>>>>>>>>>> knowing full well that it does make a difference.
The behaviour of DDD is what DDD does if executed. As DDD
takes no input
its behavour is always the same. What does "make a difference" >>>>>>>>>> mean
in this context?
The behavior of the directly executed DDD is essentially the >>>>>>>>> behavior of what would otherwise be infinite recursion except >>>>>>>>> that the second recursive call has already been aborted.
This is not the same as the behavior of DDD correctly emulated >>>>>>>>> by the same emulator that it calls where HHH cannot rely on DDD >>>>>>>>> being aborted by any other process than itself.
So the behaviour of DDD "correctly" emulated is not the behaviour >>>>>>>> of DDD.
Directly executed DDD can rely on having its second invocation
aborted by HHH is different behavior than DDD emulated by HHH
according to the behavior specified by x86 the machine code of
DDD and HHH where HHH cannot rely on DDD having already been
aborted by anything else.
DDD does not "rely" on anything. It simply is a specification of
a behaviour.
When DDD is executed before HHH its behavior its different
than when DDD is emulated by HHH. This is easy to see by
anyone that is not totally clueless about the x86 language.
The former is the behaviour of DDD. The latter is someting else though >>>> similar to some extent. That something and someting else are different >>>> is no news.
DDD emulated by each corresponding HHH that can possibly
exist never returns. Each of these HHH emulators that does
return 0 correctly reports the above non-halting behavior.
Nice to see that you don't disagree.
In other words each HHH emulator that does return 0 is a
correct termination analyzer for its corresponding DDD.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 11:15:18 |
| Calls: | 10,387 |
| Calls today: | 2 |
| Files: | 14,060 |
| Messages: | 6,416,693 |