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

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

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

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

 Many many times, dozens to hundreds of times.
The call from P to H(P,P) cannot possibly return from P
correctly simulated by H.
 

SHOW ONE WHERE I SAID IT DID, for the simulation by *H*

We can stay on this single point for the next 10,000
messages if you really want to look foolish that long.
 

So SHOW YOUR EVIDENCE.
You are just stuck in your lies.