Re: Even Google AI Overview understands me now --- HHH(DDD)==0

On 10/8/2024 6:23 PM, wij wrote:

On Tue, 2024-10-08 at 18:10 -0500, olcott wrote:

On 10/8/2024 4:27 PM, Richard Damon wrote:

On 10/8/24 5:10 PM, olcott wrote:

On 10/8/2024 3:48 PM, Richard Damon wrote:

On 10/8/24 3:11 PM, olcott wrote:

On 10/8/2024 12:51 PM, Richard Damon wrote:

On 10/8/24 10:41 AM, olcott wrote:

On 10/8/2024 9:10 AM, Richard Damon wrote:

On 10/8/24 10:03 AM, olcott wrote:

On 10/8/2024 8:21 AM, Richard Damon wrote:

On 10/8/24 8:44 AM, olcott wrote:

On 10/8/2024 6:51 AM, Richard Damon wrote:

On 10/7/24 9:28 PM, olcott wrote:

On 10/7/2024 8:11 PM, Richard Damon wrote:

On 10/7/24 8:58 PM, olcott wrote:

On 10/7/2024 7:48 PM, Richard Damon wrote:

On 10/7/24 7:36 PM, olcott wrote:

On 10/7/2024 6:04 PM, Richard Damon wrote:

On 10/7/24 6:57 PM, olcott wrote:

On 10/7/2024 5:39 PM, Richard Damon wrote:

On 10/7/24 8:08 AM, olcott wrote:

On 10/7/2024 6:02 AM, Richard Damon wrote:

On 10/6/24 10:05 PM, olcott wrote:

On 10/6/2024 8:29 PM, Richard Damon wrote:

On 10/6/24 8:05 PM, olcott wrote:

On 10/6/2024 5:36 PM, Richard Damon wrote:

On 10/6/24 3:05 PM, olcott wrote:

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.

>
Nope, whst instruction ACTUALLY EMULATE showed
a different behavior than the executed DDD?
>
All you do is look at a DIFFERENT INPUT which
is just a lie, since that isn't the DDD that
HHH was given (since the PROGRAM DDD includes
the all the exact code of the HHH that it
calls, thus you can't change it to hypothosze a
diffferent non- aborting HHH)
>

>
No one can be stupid enough to think that:
MUST BE ABORTED
    is exactly the same as
NEED NOT BE ABORTED
>

>
Who said otherwise.
>

>
The directly executed DDD need not be aborted.
DDD emulated by HHH must be aborted, thus
proving that their behavior IS NOT THE SAME.
>

>
No, the design of HHH does abort its emulation,
because if you had a DIFFERENT HHH, which would
be given a DIFFERENT DDD (since DDD includes the
HHH that it is calling) it would fail worse at
the task at the meta- level by not answering.
>

>
That you are not addressing my points seems to be
over your head.
>

>
No, the fact that I *AM* adddressing your points
and pointing out your error just proves that you
are nothing but a stupid idiot.
>
That you don't even try to point out an error in
what I say, proves that you don't actually care
about what is right, but that you just want to
blindly hold on to your position. The fact that you
consistantly snip out much of the arguement shows
that you know you are defeated, but still insist on
your WRONG position.
>
Halting is a property of PROGRAMS.

>
void DDD()
{
    HHH(DDD);
    return;
}
>
Terminating is a property of finite string machine
descriptions.
>

>
And, for the PROGRAM DDD, must include the FULL
decription of the HHH that it calls.
>

>
It does and the source-code specifies that it does
yet this is simply over-your-head.
>
https://github.com/plolcott/x86utm/blob/master/Halt7.c
>

>
But that isn't the finite string you are claiming above.
>
When you include the code of HHH in DDD, then when you
hypotosize HHH not aborting, that hypothetical HHH is
still given the DDD that calls the HHH that DOES, and
your hypothetical HHH proves that this HHH is wrong.
>

>
No it continues to be you fail to pay complete attention
to every detail of every words that I said.
>
*THE FOLLOWING REMAINS TRUE NO MATTER WHAT HHH DOES*
DDD emulated by each corresponding HHH that can possibly
exist never returns.
>

>
No, because *DDD*, the one that was emulated by each of
the HHH, will HALT if that HHH(DDD) returns 0, just after
its HHH aborted its emulaiton.
>

>
PLEASE PLAY 100% COMPLETE ATTENTION TO THESE EXACT WORDS
>
DDD emulated by each corresponding HHH
that can possibly exist never returns.
>
Your incorrect paraphrase of my words proves that
you are either clueless or deliberately deceptive.
I am going with clueless.
>

>
No, and please *PAY* 100% complete attention to these exact
words.
>
>
DDD emulated by HHH is NOT the same thing as the emulation
of DDD by HHH.
>
DDD emulated by HHH, is the full behavior of the full
program DDD, which one we are talking about. That behavior
does not "stop" just becuase the HHH that was emulating it
stopped its emulation.
>
>
I didn't "paraphrase" your words, I looked that the exact
words you said, and looked at the grammatical construction.
If you disagree with my analysys, point out the error.
>

>
Every executed HHH that returns 0 correctly reports that
no DDD emulated by its corresponding HHH ever returns.
>
You paraphrased this as some kind of "vacuous truth".
>

>
I didn't paraphrase you, I showed you what the words mean,
but apparently you are too stupid to understand.
>
How can those HHH be correct when there answer is wrong.
>
There answer is wrong because for EVERY HHH that returned 0,
the DDD that the emulated WILL return,

>
"the DDD that the emulated WILL return"
Seems like gibberish nonsense.

>
type, the DDD that was emullated WILL return
>

>
counter-factual
>

>
Proven by your own traces.
>

>
01 void DDD()
02 {
03  HHH(DDD);
04  return;
05 }
>
Every executed HHH emulates 01,02,03 of DDD
then either endlessly emulates itself emulating lines 01,02,03
of DDD never reaching line 04 of DDD or aborts the emulation
before ever reaching line 04 of DDD and returns some value.

>
So, you are not ADMITTING that the above is not a proper "finite-
string" represention of the program DDD, as it doesn't define what
DDD actually does as it depend on which of the choices HHH does.
>

>
This may all be your unintentional inability
to pay close enough attention.

>
No, it is you not understanding English, and it seems INTENTIONAL
DECEPTIVE just showing your pathological lying.
>

>
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
>
>

>
No, if HHH(DDD) returns 0 when it is directly executed, then it will
return 0 to DDD when DDD is directly exectuted

>
Changing the subject counts as a strawman deception rebuttal.
Terminating is a property of finite string machine descriptions.

>
So, you are admitting that your work is just rubbish.
>
Terminationg is a property of a Machine/Program
>
Remember the definition, a Machine halts when it reachs a final state.
And a non-halting machine is a machine the NEVER reaches a final state,
even after an unlimited number of steps.
>
Finite-Strings are just ways we encode data to give to machines as a
representation for things they can not directly process.
>
I guess you failed CS 101.
>
>

>

or correctly (and completely emulaitod, something that HHH can't do),
and thus DDD halts.
>

>
DDD cannot be completely emulated by HHH for the same sort
of logical impossible reason that squares cannot be round.

>
Right, and since HHH can not completely emulate DDD, even when it is a
halting program, HHH can't use its only emulation as the defining
characterist of the input.
>
You just agreeing that your whole premise is just a strawman, and that
you have wasted the last decades of your life on your own errors.
>
>

>
My above paragraph is factually correct and your
paraphrase of this paragraph is factually incorrect.
>
>

>
Your paragraph has factually correct statements in it that proves that
you conclusion is just incorrect.
>
The fact that you can't point out the errors in what I say, says that
you accept my explaination and are admitting that you are just a liar.
>
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.
>

>
DDD emulated by each corresponding HHH
that can possibly exist never returns
NO MATTER WTF THAT ITS EXECUTED HHH DOES.
>

 That is right. So the HHH cannot WHT be a halting decider.
 

DDD emulated by each corresponding HHH that can possibly
exist never returns
thus each of the directly executed  HHH emulators that does
return 0 correctly reports the above non-terminating behavior.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer