Re: DDD correctly emulated by H0 --- Why Lie?

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

On 6/23/2024 9:16 PM, Richard Damon wrote:

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

On 6/23/2024 9:00 PM, Richard Damon wrote:

On 6/23/24 9:36 PM, olcott wrote:

On 6/23/2024 8:30 PM, Richard Damon wrote:

On 6/23/24 9:20 PM, olcott wrote:

On 6/23/2024 8:13 PM, Richard Damon wrote:

On 6/23/24 9:00 PM, olcott wrote:

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

On 6/23/24 8:08 PM, olcott wrote:

On 6/23/2024 6:44 PM, Richard Damon wrote:

On 6/23/24 7:34 PM, olcott wrote:

On 6/23/2024 5:58 PM, Richard Damon wrote:

On 6/23/24 6:45 PM, olcott wrote:

>
You know what the freak I was talking from prior
discussions unless your brain is so damaged that
you can't remember anything from one post to the next.
>
In the case that you affirm that your brain <is>
this damaged then I humbly apologize.
>

>
>
No, you don't know what you are talking about.
>

So you insist on lying about this verified fact?
>
_DDD()
[00002172] 55               push ebp
[00002173] 8bec             mov ebp,esp
[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]
>
According to the semantics of the x86 programming language
when DDD correctly emulated by H0 calls H0(DDD) this call
cannot possibly return.
>

>
I won't say it can't be true, but it hasn't been proven, largely because it seems you don't know how to do a formal logic proof.
>

>
Liar
>

>
Then where is the proof?
>
And were is the simulation that H0 did?
>
Failure to show where you ACTUALLY PROVED it just shows you a liar.
>
Remember the parts of a Formal Logic Proof:
>

>
You could disagree that 2 + 3 = 5 on this same Jackass basis.
2 + 3 = 5 ON THE FREAKING BASIS OF THE SEMANTICS OF ARITHMETIC.

>
But I seen proofs that 2 + 3 = 5
>
And that is done on a proof that uses the semantics of aritmetic.
>
The phrase "Semantics of Arithmetic" though, is not a proof.
>

>
According to the semantics of the x86 programming language
when DDD correctly emulated by H0 calls H0(DDD) this call
cannot possibly return.
>

>
Then try to prove it.
>

>
I will not try any prove that 2 + 3 = 5, if you deny
it then you are a liar.

>
And you don't need to, as it has been done.
>
Now, showing how 2 + 3 = 5 would help show you how to right an actual proof.
>

>
Likewise for the behavior of DDD correctly simulated
by H0. A correct x86 emulator already proved this three
years ago and you still try and get away with lying about it.

>
Nope. Just a fallacy of proof by example, which isn't a proof.
>

>
We have gotten it down to this ONLY LIARS WILL DISAGREE
THAT MY PROOF IS CORRECT.

>
WHAT PROOF?
>
No proof, just means your statement is just a LIE.
>

>
DDD correctly emulated by H0 DOES NOT HALT.

>
TYPE ERROR.
>
Correct Simutation by H is not part of the definition of HALTING.
>
Just proves your ignorance of what you talk about.
>
>

Likewise for P correctly emulated by H.

>
AGAIN TYPE ERROR.
>
Correct Simutation by H is not part of the definition of HALTING.
>
Just proves your ignorance of what you talk about.
>

>
typedef int (*ptr2)();
int H(ptr2 P, ptr2 I);
>
int P(ptr2 x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
int main()
{
   H(P,P);
}
>
_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]
>
>
>

>
>
And, P(P) Halts since you have indicated that H(P,P) to returns 0.
>
VERIFIED FACT.
>

>
A verified fact to a God damned liar.

>
Nope, actual verified fact, one YOU have even proven and agreed to.
>
SO, I guess you are just showing you are just a LIAR.
>
>

>
The actual verified fact is that when P is correctly emulated
by H according to the semantics of the x86 language that the
call from P to H(P,P) CANNOT POSSIBLY RETURN.
>

>
But that isn't halting, so saying it shows non-halting is just a LIE, and proves your ignorance of the topic.

>
So you agree that the call cannot possibly return
or are you going to keep lying about that?
>

>
No, I am saying the call WILL return in the direct execution, which is what matters.
>

 So finally after three years you quit lying about the
behavior of P correctly simulated by H.
 It should not have taken that long to get you to quit
being dishonest.
 

When did I ever say anything like that about the correct simulation by H.
I have said you haven't proved it, because you haven't, and probably don't have the knowledge to do so.
I have said it is meaningless, because it isn't the definition needed for halting (particularly for non-halting).
SO, it seems you are just being your normal pathological liar that has run out of excuses so go for the ad-homenem.