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

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.
the behavior of "DDD emulated by any corresponding HHH" refers to the behavior of the full program DDD (including all the code of the specific HHH that it calls) either directly executed or given to an emulator that doesn't abort.
This behavior is to halt for EVERY DDD that calls an HHH(DDD) that aborts its simulation and return.
The behavior you seem to want to describe is something different, that the Emulation of every DDD by HHH does not reach the final state.
The difference comes from the English Grammer. The statement you use has DDD as the subject, and thus the actual behavior of that program is what is being talked about. In the second, the Emulation is the subject, so that is what is being talked about.
Of course, you don't want to use the second version as it makes it clear that you aren't actually talking about the real behavior of DDD, and it is obvious that an emulator that aborts won't reach the final state.
This has been explained to you many times, but you have just repeatedly demonstated that you don't care what is actually true, you just what to make you lying claims.
So, 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.