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

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

On 6/25/2024 9:54 PM, Richard Damon wrote:

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

On 6/25/2024 9:17 PM, Richard Damon wrote:

On 6/25/24 9:59 PM, olcott wrote:

On 6/25/2024 8:47 PM, Richard Damon wrote:

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.
>

>
Maybe the real problem is that you have insufficient technical competence.

>
Nope, that isn't the problem. I KNOW what I am talking about, as opposed to you who can't even write a simple Turing Machine.
>

>

Your problem is that, strictly, by your definition of "Correct Simulation",

>
The semantics of the x86 language objectively proves that I am correct.
Have you been faking your technical competence?

>
Nope.
>

>
Can you do better with this simpler example?
>
_DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
>
The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return.
>
>

>
But the call will, just not in the simulation that your H0 does.
>

>
OK so we are back to you being a freaking liar trying to get
away with contradicting the semantics of the x86 language.
>

>
How does that contradictthe semantics of the x86 languge?
>
If H0 is a decider, it will ALWAYS return an answer in finite time

 H0 is not even a decider yet. When you leap ahead you
diverge from the point at hand.
 

THen it is allowed to be the impure function , so you r claim is proven false.
You can't use double speak and claim you ment that, but not that H0 isn't a decider.
So, your FAIL.
And, by the definition of "Correct Simulation" per the STRICT x86 definition, it CAN'T be a decider, as it isn't allowed to "abort" since the actual x86 code doesn't abort.