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

On 6/22/24 9:15 AM, olcott wrote:

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.
 

The CALL H instruction

Since you already know that none of them were emulated incorrectly
I suggest that you repent.

Really, then why have you been unable to post the actual trace of the simulation of DDD (or D, or DD) simulated by H (or HH, or HH0, or whatever) that actually shows a correct simulation of the call to the decider instruction.
Your short inline traces NEVER actually simulate that call instruction, but switch to looking at the simulation that was being CONDITIONALLY simulated (since the decider has the option to abort) instead of showing the act of simulation with the conditional in that operation.
Your long traces have alwasy been the execution trace of the simulator its self, and not the simulation it was doing.
So, your "verifaction" is based on somethng that you have been unable to produce, and almost certainly something you haven't actually seen for yourself (or you would have post it instead of the wrong trace TWICE).
I will point out that you seem to be willing to gamble your eternal soul on facts that you just beleive must be true, even though everyone is pointing out your errors.
It seems that what ever "Heaven" you get to, you are apt to be alone in it, which will mean it isn't Heaven.

 

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.