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

On 6/24/2024 7:54 PM, Richard Damon wrote:

On 6/24/24 8:34 PM, olcott wrote:

On 6/24/2024 7:06 PM, Richard Damon wrote:

On 6/24/24 8:02 PM, olcott wrote:

On 6/24/2024 6:59 PM, Richard Damon wrote:

On 6/24/24 7:43 PM, olcott wrote:

On 6/24/2024 6:19 PM, Richard Damon wrote:

On 6/24/24 9:42 AM, olcott wrote:

On 6/24/2024 6:02 AM, Richard Damon wrote:

On 6/23/24 11:26 PM, olcott wrote:

On 6/23/2024 10:11 PM, Richard Damon wrote:

On 6/23/24 10:52 PM, olcott wrote:

>

>

>
for the next 10,000 messages if you really want to look
foolish that long.
>
>

>
Go ahead, stall your argument till you die.

>
There is no sense moving on to the next point until AFTER
you quit lying about this point.
>
_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 P to H(P,P) when P is correctly emulated
by H cannot possibly return.
>
>

>
And my reply, like always, So?
>

>
Since you are such a damned liar I am not going to give
you two different points to endlessly switch back and forth
between. I am going to keep repeating this point to prove
what a damned liar you really are.
>

>
What is the LIE?
>
It seems YOU are the LIAR.
>

void DDD()
{
   H0(DDD);
}
>
_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.
>
Once we have closure on this point we can move on to
the last point.
>

>
And what do we care about it?
>

>
*It is the only thing that you will get to talk to me about*
*It is the only thing that you will get to talk to me about*
*It is the only thing that you will get to talk to me about*
*It is the only thing that you will get to talk to me about*
>

>
Good, so you are admitting you have nothing important to say.

>
I do correctly refute the halting problem proofs and
mandate mutual agreement on each step before I will
proceed to the next step.

 Nope, you never have because you never use the definition of HALTING,

*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*
D correctly simulated by H does not have the same behavior
as the directly executed D(D) because
the call from D to H(D,D) cannot possibly return when D
is correctly simulated by H.
  D correctly simulated by H
cannot possibly return from its call to H(D,D).
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer