Re: Even Google AI Overview understands me now --- different execution traces have different behavior !!!

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:

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

>

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=Termination+Analyzer+H+is+Not+Fooled+by+Pathological+Input+D&gs_lp=Egdnd3Mtd2l6IjxUZXJtaW5hdGlvbiBBbmFseXplciBIIGlzIE5vdCBGb29sZWQgYnkgUGF0aG9sb2dpY2FsIElucHV0IERIAFAAWABwAHgAkAEAmAEAoAEAqgEAuAEDyAEA-

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.]
>
### 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.
>

*You can continue this conversation with ChatGPT*

I’ll leave that to you.

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.
 

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
Thus, your "criteria" is just foolishness.
Which you have accepted as truth, since you have decide to not even try top point out the instruction the HHH actually correctly emulated that differed from its behavior when directly executed.
The closest you have come is trying to claim that HHH can "somehow" determine that the HHH that DDD calls won't return, but does so by violating the definitions.
Either the HHH that we are looking at isn't actually a program, or
the DDD that we are looking at isn't actually a program, or the program that it is actually looking at isn't the same program as the DDD that was run.

Everyone besides Mike is simply not bright enough
to see this. Mike can see this yet refuses to admit
that he sees this.
 

No, you are just showing that:
PPPP   EEEEE  TTTTT  EEEEE  RRRR
P   P  E        T    E      R   R
P   P  E        T    E      R   R
PPPP   EEEEE    T    EEEEE  RRRR
P      E        T    E      R R
P      E        T    E      R  R
P      EEEEE    T    EEEEE  R   R
  OOO   L       CCC    OOO   TTTTT  TTTTT
O   O  L      C   C  O   O    T      T
O   O  L      C      O   O    T      T
O   O  L      C      O   O    T      T
O   O  L      C      O   O    T      T
O   O  L      C   C  O   O    T      T
  OOO   LLLLL   CCC    OOO     T      T
L     IIIII  EEEEE   SSS
L       I    E      S   S
L       I    E      S
L       I    EEEEE   SSS
L       I    E          S
L       I    E      S   S
LLLLL IIIII  EEEEE   SSS
AND THINKS THAT IS JUST OK.