Re: The philosophy of computation reformulates existing ideas on a new basis ---Olcott proves he is a liar

On 11/10/24 9:51 AM, olcott wrote:

On 11/10/2024 5:56 AM, Richard Damon wrote:

On 11/9/24 10:36 PM, olcott wrote:

On 11/9/2024 9:30 PM, Richard Damon wrote:

On 11/9/24 10:10 PM, olcott wrote:

On 11/9/2024 9:03 PM, Richard Damon wrote:

On 11/9/24 9:53 PM, olcott wrote:

On 11/9/2024 8:48 PM, Richard Damon wrote:

On 11/9/24 9:38 PM, olcott wrote:

On 11/9/2024 8:11 PM, Richard Damon wrote:

On 11/9/24 9:01 PM, olcott wrote:

On 11/9/2024 7:59 PM, Richard Damon wrote:

On 11/9/24 8:28 PM, olcott wrote:

On 11/9/2024 6:19 PM, Richard Damon wrote:

On 11/9/24 6:43 PM, olcott wrote:

On 11/9/2024 2:56 PM, Richard Damon wrote:

On 11/9/24 3:01 PM, olcott wrote:

>
On 11/3/2024 12:20 PM, Richard Damon wrote:
 > On 11/3/24 9:39 AM, olcott wrote:
 >>
 >> The finite string input to HHH specifies that HHH
 >> MUST EMULATE ITSELF emulating DDD.
 >
 > Right, and it must CORRECTLY determine what an unbounded
 > emulation of that input would do, even if its own programming
 > only lets it emulate a part of that.
 >
>

>
I am saying that HHH does need to do the infinite emulation itself, but

>
Right and it doesn't.

>
But doesn't give the required answer, which is based on something doing it.
>

>
The unaborted emulation of DDD by HHH DOES NOT HALT.
*Maybe I have to dumb it down some more*

>
But that isn't the HHH that you are talking about.
>
It seems, you don't understand that in a given evaluation, HHH and DDD are FIXED PROGRAM.
>

>
HHH predicts what would happen if no HHH ever aborted
its emulation of DDD. This specific DDD never halts
even if it stops running due to out-of-memory error.
>

>
In other words, it tries to predict what some OTHER version of the program DDD would do if it was based on some OTHER version of HHH,

>
*Yes just like you agreed that it should*
>
On 11/3/2024 12:20 PM, Richard Damon wrote:
 > Right, and it must CORRECTLY determine what an unbounded
 > emulation of that input would do,
 > even if its own programming only lets it emulate a part of that.
>

>
Nope, never said it could immulate some OTHER input, or predict what some OTHER program does.
>

>
You said that the bounded HHH
 > must CORRECTLY determine what an unbounded
 > emulation of that input would do,
>

>
Right, the UNBOUNDED EMULATION, not the results of a different DDD that called an HHH that did an unbounded emulation.
>
The input doesn't change, and the input specifies the HHH that DDD calls. so that doesn't change.

>
What changes is that the HHH that does abort must
report on what the behavior of DDD would be if it
never aborted.
>

>
No, the HHH that the input call can not change, or everything that you say afterwords is just a lie.
>
HHH doesn't report on the non-sense idea of it being something different than it is, that is just foolishness.
>

>
On 11/3/2024 12:20 PM, Richard Damon wrote:
 > must CORRECTLY determine what an unbounded
 > emulation of that input would do,
 > even if its own programming only lets it emulate a part of that.
 >
>
HHH
 > must CORRECTLY determine what an unbounded
 > emulation of that input would do,
>
 > even if its own programming only lets it emulate a part of that.
 >
Even HHH itself is bounded
>
>

>
Right, but that unlimited emulation isn't done by CHANGING the copy of HHH that DDD calls, but by giving the input to a DIFFERENT program than HHH that does the unlimited emulation,

>
*That is NOT what you said*
>
On 11/3/2024 12:20 PM, Richard Damon wrote:
 > [HHH itself] must CORRECTLY determine what an unbounded
 > emulation of that input would do,
>
 > even if its own programming only lets it emulate a part of that.
 >
>

>
No, that *IS* what I said, you just don't hear right, because you "filter" thing through your stupidity.
>
I said emulation of *that* input.
>

>
HHH must determine what would happen if HHH never aborted DDD.
>

>
That is nonsense, as HHH does what HHH does, and the other machibne you call HHH that never aborts isn't HHH, so this DDD doesn't call it.
>

 That *is* the fundamental principle of emulating termination
analyzers that works correctly on infinite loops and infinite
recursion. ChatGPT fully comprehends the correctness of this
principle and cannot be convinced otherwise.

Nope, so you are just admitting that you don't understand what you are talking about.
Can you find ANY reputable source that defines it your way, where ALL copies of the decider get changed for that decision?

 *ChatGPT*
Simplified Analogy:
Think of HHH as a "watchdog" that steps in during real execution
to stop DDD() from running forever. But when HHH simulates DDD(),
it's analyzing an "idealized" version of DDD() where nothing stops the
recursion. In the simulation, DDD() is seen as endlessly recursive, so
HHH concludes that it would not halt without external intervention.
https://chatgpt.com/share/67158ec6-3398-8011-98d1-41198baa29f2

But HHH isn't "just a watchdog", it is PART of the program DDD, so your explanation was just based on a lie.
The real DDD doesn't run forever, because the code for HHH that you clai is correct does abort and return, and thus DDD returns.
DDD isn't calling an "idealized" version of HHH, but the actual programn HHH, so that is another LIE.

 The author of the best selling book on the Theory of Computation
also agrees with this principle
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its input D
     until H correctly determines that its simulated D would never
     stop running unless aborted then
      H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
 A correct simulation is defined as H emulating D according to the
semantics of the x86 language. This does include H emulating itself
emulating D.

But since H doesn't DO a "correect simulation" (which in the field implied complete) the emulation by H can't be used, and the actual emulation of D (sihce it calls that H that answers) returns, H can't "correctly determine" that it doesn't

 Furthermore you yourself agree
 On 11/3/2024 12:20 PM, Richard Damon wrote:
 > On 11/3/24 9:39 AM, olcott wrote:
 >>
 >> The finite string input to HHH specifies that HHH
 >> MUST EMULATE ITSELF emulating DDD.
 >
 > Right, and it must CORRECTLY determine what an unbounded
 > emulation of that input would do, even if its own programming
 > only lets it emulate a part of that.
 >
  > [HHH itself] must CORRECTLY determine what an unbounded
 > emulation of that input would do,
  > even if its own programming
 > only lets it emulate a part of that.
 >
 even though HHH itself is a bounded emulation.

And not that was of THAT input, which is the DDD that calls the HHH that does abort, and the correct and complete emulation of THAT reaches the end.

 Clearly one that disagrees with their own self is
one that is incorrect.
 

And one that continually lies by mis-quoting and mis-interpreting what people says just shows they are nothing but a damned ignorant pathological liar.