Re: DDD correctly emulated by H0 --- Why Lie? -- Repeat until Closure

On 6/25/24 9:02 AM, olcott wrote:

On 6/25/2024 6:04 AM, Richard Damon wrote:

On 6/24/24 11:13 PM, olcott wrote:

On 6/24/2024 9:48 PM, Richard Damon wrote:

On 6/24/24 10:38 PM, olcott wrote:

On 6/24/2024 9:26 PM, Richard Damon wrote:

On 6/24/24 10:21 PM, olcott wrote:

On 6/24/2024 9:02 PM, Richard Damon wrote:

On 6/24/24 9:55 PM, olcott wrote:

>
*We can get to that as soon as you reverse your lie*
*We can get to that as soon as you reverse your lie*
*We can get to that as soon as you reverse your lie*

>
You still haven't shown where I lied, on where you don't like what I say.
>

>
You said that D correctly simulated by H must
have the behavior of the directly executed D(D).

>
Right, the steps that H sees are IDENTIAL to the steps of the directly executed D(D) until H stops its simulation,
>
NOT ONE DIFFERENCE.
>

>
Honest mistake or liar?
>
The directly executed D(D) has identical behavior to
D correctly simulated by H1
*the call from D to H(D,D) returns*
>
This is not the same behavior as
D correctly simulated by H
*the call from D to H(D,D) DOES NOT return*
>

>
And what instruction did H's simulation differ from the direct executions trace?
>

>
D correctly simulated by H
*the call from D to H(D,D) DOES NOT return*

>
Which isn't "Behavior of the input"
>
The "not happening" of something that could have happened except that the processing was stoped is NOT behavior.
>

>
D correctly simulated by H1 --- Identical to D(D)
*the call from D to H(D,D) returns*
>

>
Right, and it contains ALL of the behavior of the correct simulation of D by H, plus more.
>
H doesn't see DIFFERENT behavior, just LESS, and that differnce isn't due to the input, but due to H.

>
*These are not the same behaviors*
>
(Assuming unlimited memory)
When 1 to a googolplex of steps of D are correctly simulated by H
*the call from D to H(D,D) NEVER RETURNS*

>
Correction, 1 to a googleplex of steps if DIFFERENT Ds, each paired with a DIFFERENT H, when simulated by that H, the DIFFFERENT routines called by those DIFFERENT Ds to that DIFFERENT H(D,D) is never simulated to an end.
>

 _P()
[000020e2] 55               push ebp         ; housekeeping
[000020e3] 8bec             mov ebp,esp      ; housekeeping
[000020e5] 51               push ecx         ; housekeeping
[000020e6] 8b4508           mov eax,[ebp+08] ; parameter
[000020e9] 50               push eax         ; push parameter
[000020ea] 8b4d08           mov ecx,[ebp+08] ; parameter
[000020ed] 51               push ecx         ; push parameter
[000020ee] e82ff3ffff       call 00001422    ; call H(P,P)
[000020f3] 83c408           add esp,+08
[000020f6] 8945fc           mov [ebp-04],eax
[000020f9] 837dfc00         cmp dword [ebp-04],+00
[000020fd] 7402             jz 00002101
[000020ff] ebfe             jmp 000020ff
[00002101] 8b45fc           mov eax,[ebp-04]
[00002104] 8be5             mov esp,ebp
[00002106] 5d               pop ebp
[00002107] c3               ret
Size in bytes:(0038) [00002107]
 The call from D to H(D,D) cannot possibly return when D
is correctly simulated by any H that can possibly exist.
 Unless you say yes you are correct we cannot move on to
the next point.
 

No, the call most definitinely DOES return, but that return is after the simulation ended.
Your problem is that, strictly, by your definition of "Correct Simulation", every instruction simulated, that isn't a HALT instruction, or the ret instruction for the implied call to the routine really needs to be followed by the simualation of the following instruction, as that is actually part of the definition of the behavior of that instruction you simulated.
Yes, you can modify your definition slightly to allow the decider to abort its simulation at a point that it chooses, but then you have an admitted PARTIAL simulaiton, and one key aspect of a partial simulation is that it gives no indication (by itself) of anything that happens after the point of the interruption.
So, you can't that the call will not have a return, only that it didn't have a return to the point of the simulation, or that there was no such return in the duration of the simulation.
And, you comment about "any H" is just an invalid statement about THIS input, as each H has a different input, and it is most definitely true that if we give THIS input, bound to THIS H, there is another alternate H (H') that simulates long enough that it WILL see that return.
And, your logic requires that you be this sort of sloppy, as it is clear that you intend to wiggle you definitions as you go to claim things that are just not true, so you NEED to be precise in your words to get an agreement from me.
ALso, if you want to be able to say you have PROVED this, you need to actually present a actual proof, not just a claim that you can build a proof, based on a baseless claim that no one can come up with a counter example.
The lack of a found counter example is NOT proof that no such counter example can exist, so isn't a piece of a valid logical arguement.
You need to actually produce such a proof to make the claim that it is proven, and such a proof will, by necessity, firm up your definition of exactly what you mean, which may be one reason you can't come up with one, as you know it will box you in a corner.