Re: DDD specifies recursive emulation to HHH and halting to HHH1

On 3/28/2025 3:45 PM, dbush wrote:

On 3/28/2025 3:38 PM, olcott wrote:

On 3/28/2025 2:20 PM, dbush wrote:

On 3/28/2025 3:15 PM, olcott wrote:

On 3/28/2025 4:33 AM, Fred. Zwarts wrote:

Op 28.mrt.2025 om 02:21 schreef olcott:

On 3/27/2025 8:09 PM, dbush wrote:

On 3/27/2025 9:07 PM, olcott wrote:

On 3/27/2025 7:38 PM, dbush wrote:

On 3/27/2025 8:34 PM, olcott wrote:

On 3/27/2025 7:12 PM, dbush wrote:

On 3/27/2025 8:11 PM, olcott wrote:

On 3/27/2025 7:02 PM, dbush wrote:

On 3/27/2025 7:36 PM, olcott wrote:

On 3/27/2025 1:27 PM, dbush wrote:

On 3/27/2025 1:50 PM, olcott wrote:

On 3/27/2025 2:18 AM, Fred. Zwarts wrote:

Op 27.mrt.2025 om 04:09 schreef olcott:

On 3/26/2025 8:22 PM, Richard Damon wrote:
>
_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]
>

Non-Halting is that the machine won't reach its final staste even if an unbounded number of steps are emulated. Since HHH doesn't do that, it isn't showing non-halting.
>

>
DDD emulated by any HHH will never reach its final state
in an unbounded number of steps.
>
DDD emulated by HHH1 reaches its final state in a finite
number of steps.
>

It is not very interesting to know whether a simulator reports that it is unable to reach the end of the simulation of a program that halts in direct execution.

>
That IS NOT what HHH is reporting.
HHH correctly rejects DDD because DDD correctly
emulated by HHH cannot possibly reach its own
final halt state.

>
In other words, HHH is not a halt decider because it is not computing the required mapping:
>

>
Troll
>

>
On Monday, March 6, 2023 at 3:19:42 PM UTC-5, olcott wrote:
 > In other words you could find any error in my post so you resort to the
 > lame tactic of ad hominem personal attack.
>

>
Troll
>

>
On 7/22/2024 10:51 AM, olcott wrote:
 > *Ad Hominem attacks are the first resort of clueless wonders*
>

>
I corrected your error dozens of times and you
ignore these corrections and mindlessly repeat
your error like a bot

>
Which is what you've been doing for the last three years.
>
Projection, as always.  I'll add the above to the list.
>

>
TM's cannot possibly ever report on the behavior
of the direct execution of another TM.

>
False:
>

>
I did not say that no TM can ever report on
behavior that matches the behavior of a directly
executing TM.
>
No TM can every directly see the behavior of the
direct execution of any other TM because no TM can
take a directly executing TM as an input.
>

So we agree that the answer for:
'Is there an algorithm that can determine for all possible inputs whether the input specifies a program that (according to the semantics of the machine language) halts when directly executed?'
is 'no'. Correct?

>
In the same way: Is there an algorithm that correctly
determines the square root of a box of rocks?
>

>
>
In other words, you're saying that there's a TM/input where the question of whether or not it halts when executed directly has no correct yes or no answer.
>
Show it.
>

>
I proved it many times and because you are a Troll you
ignored the proof that by definition no TM can take
an executing TM as its input, thus cannot possibly
report on something that it does not see.

 You have shown no such machine that neither halts nor doesn't halt when executed directly.
 

>

Failure to do so in your next message is your on-the-record admission that the above question is valid.

>
When include ALL of the relevant details to the question
it becomes:
>
What Boolean value can decider H correctly return when input
D is able to do the opposite of whatever value that H returns?
>
We can reject this question entirely when we discard its
false assumption.

  And that false assumption is that an H exists that behaves as specified below, proving Linz:
  Given any algorithm (i.e. a fixed immutable sequence of instructions) X described as <X> with input Y:
 A solution to the halting problem is an algorithm H that computes the following mapping:
 (<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly
 

I'll take your lack of response to the above that you agree that the false assumption to be discarded is that an H exists that behaves as specified above, which is exactly what the Linz proof states, and that you therefore agree that the Linz halting theorem and proof are correct.