Re: H(D,D) cannot even be asked about the behavior of D(D) --- Boilerplate Reply

On 6/22/2024 8:05 AM, Richard Damon wrote:

On 6/22/24 12:18 AM, olcott wrote:

On 6/21/2024 11:09 PM, joes wrote:

Am Fri, 21 Jun 2024 15:52:21 -0500 schrieb olcott:

On 6/21/2024 3:00 PM, Richard Damon wrote:

On 6/21/24 3:45 PM, olcott wrote:

On 6/21/2024 2:33 PM, Richard Damon wrote:

On 6/21/24 3:19 PM, olcott wrote:

>

When H is asked H(D,D) this maps to D correctly simulated by H.

Like every other input, it should map to the behaviour of D(D).
You are talking about H(H, D(D)), which is H simulating itself.

When H is asked H(D,D) this DOES NOT map to behavior that halts.

Only if H returns.
>

Nope. H(M,d) is DEFINED (if it is correct) to determine if M(d) will
Halt.

If one "defines" that the input to H(D,D) maps to the behavior of D(D)
yet cannot show this because it does not actually map to that behavior
*THEN THE DEFINITION IS SIMPLY WRONG*

Ridiculous. H is wrong. Your modification is not useful.

But we CAN show that it maps to the behavior of D(D) (at least when the
representation of D includes the H that is giving the 0 answer) by just
runnig it and seeing what it does.

No you cannot show that the mapping for the input to H(D,D) maps to the
behavior of D(D).

If it doesn't, H is not a simulator.
The input D(D) absolutely describes the behaviour of that machine.
H just can't map it.
>

You assume that the call to H(D,D) from D correctly simulated by H *must
return* against the verified facts that it does not return.

Either H is not a decider or it returns.
>

The directly executed D(D) is essentially the first call in a recursive
chain where the second call is always aborted.
*these two calls are not identical*

They most definitely are. The input is the same.
>

H(D,D) is not free to simply assume that the call from D(D) to H(D,D)
will return.

Yes it is, because it is a decider. It (incorrectly) aborts nonterminating
inputs.
>

>
The behavior of D correctly simulated by H1 is the same as
the behavior of the directly executed D(D) because D does not
call H1(D,D) in recursive simulation.
>
The behavior of D correctly simulated by H is NOT the same as
the behavior of D correctly simulated by H1 because D DOES
call H(D,D) in recursive simulation.
>

 Which just shows that H doesn't do an OBJECTIVELY "Correct Simulation".
 

If you weren't simply lying about this and risking eternal damnation
then you could point out which x86 instruction was emulated incorrectly.
Since you already know that none of them were emulated incorrectly
I suggest that you repent.

The error in the simulation has been pointed out, but you just don't understand it, it seems because you think truth is just naturally subjective, but it isn't.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer