Re: HHH(DDD) correctly determines the halt status of its input according to this specification

On 5/14/25 10:10 PM, olcott wrote:

On 5/14/2025 8:55 PM, Richard Damon wrote:

On 5/14/25 3:17 PM, olcott wrote:

On 5/14/2025 2:06 PM, Mike Terry wrote:

On 14/05/2025 18:50, Mike Terry wrote:

On 14/05/2025 08:11, vallor wrote:

Spent a couple of hours reading back the last few days of posts. Huboy,
what a train wreck.  (But like a train wreck, it's hard to look
away, which might explain how this has been going on for 20(?) years.)
>
I want to thank both Richard's, wij, dbush, Mike, Keith, Fred,
Mikko, and anybody else I've forgotten for trying to explain to
Mr. Olcott and Mr. Flibble how you all see their claims.  I wanted to
point out three things:
>
a) Mr. Olcott claims his HHH simulator detects an non-terminating
input and halts.  But others (I forget who) report that -- due
to a bug -- D would actually terminate on its own.  His HHH
simulator therefore gives the wrong answer.

>
Not really due to a bug.  D actually /does/ terminate on its own, and that's a consequence of PO's intended design.  (Yes, there are bugs, but D's coding is what PO intended.)
>

Hmm, I thought some more about this.  What's considered a bug (rather than e.g. a design error) is entirely dependent on the program's specification.

>
void DDD()
{
   HHH(DDD);
   return;
}
>
<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

>
Since you DDD isn't a program, since you say that it doesn't include the HHH that it calls, means that you can't use this, since here D *IS* a program, as that is from the defintion of a Halt Decider, its input is the representation OF A PROGRAM.
>

>
I did not notice how all of the rebuttals of this have
always committed the straw-man error until yesterday.
>
_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]
>
A correct simulation has always meant that according
to the rules of the x86 language HHH must emulate
itself emulating DDD.

>
>
Right, which fails at the call to HHH,

 Liar!
 

So, how does it LEGALLY do it?
The code of HHH is not part of the input, so HHH can not correctly emulate its input *DDD* and go somewhere else.
If you were told to measure how much pipe was underground, and you measured all the way up to the upstairs bathroom, you just measured the wrong thing.
WHen asked about the simulation of "DDD", then you must only look at DDD.
If the code is supposed to be part of what you are to look at, it needs to be part of the input.
Since you have EXPLICITLY said it isn't, you can't look at it, unless of course you admitt that you logic is based on lying about the defintions of things.
Until you actually answer some of these questions, the only possible answer is that you are just a liar with no proper basis for your claims.
If you don't understand something I say, ask for clarification.
If you disagree with my definitions, point that out and provide a reliable source for something that you do agree with.
Otherwise, you are just proving that you are just a pathological liar.