Re: Anyone that claims this is not telling the truth

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

On 8/17/2024 5:21 PM, Richard Damon wrote:

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

On 8/17/2024 5:09 PM, Richard Damon wrote:

On 8/17/24 5:43 PM, olcott wrote:

On 8/17/2024 4:11 PM, Richard Damon wrote:

On 8/17/24 5:05 PM, olcott wrote:

On 8/17/2024 4:00 PM, Richard Damon wrote:

On 8/17/24 4:41 PM, olcott wrote:

On 8/17/2024 3:20 PM, Richard Damon wrote:

On 8/17/24 4:10 PM, olcott wrote:

On 8/17/2024 2:27 PM, Richard Damon wrote:
 > On 8/17/24 3:00 PM, olcott wrote:>> On 8/17/2024 1:50 PM, Richard Damon wrote:
 >>>>>> And thus ALL of memory is part of the input,

>
Any additional details have no effect what-so-ever on my claim.
>

>
Suure it does.
>
Since your argument tries to say that since DDD is the same to all of them, so its the behavior.
>
You are just admitting to being a LIAR.
>

>
*Calling me a liar admits that insults is all that you have*
*If I made a mistake then show that*

>
I did.
>

>
FOR THREE YEARS YOU ALWAYS CHEAT
BY CHANGING MY WORDS AND REBUTTING THESE CHANGED WORDS
>
*Everything that is not expressly stated below is*
*specified as unspecified*

>
Ok.
>

>
void DDD()
{
   HHH(DDD);
}
>
_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]
>
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
>

>
No, DDD can NOT be emulated accoreding to the semantics of the x86 langauge, because the contents of the location 000015d2 is not provided to be emulated, and will need to be emulated after emulating the call instruction.
>

>
Everything that is logically entailed by the above specification
is included by reference. The assumption that DDD and HHH were
not in the same memory space has always been ridiculous.
>

>
Then I guess you accept that every different HHH generates a DIFFERENT Input, as that input, BY LOGHICAL NECESSITY includes all the code of HHH so it can be emulated, and thus you claims that "All the DDDs have the same bytes" is just a blantent lie.
>

>
This is my only claim
*It is a basic fact that DDD emulated by HHH according to*
*the semantics of the x86 language cannot possibly stop*
*running unless aborted* (out of memory error excluded)
>
I am not claiming anything about any bytes.
>
>

>
And, as I point out, that isn't true if HHH ever aborts its simulation.
>

>
That is merely agreeing with what I said
>
X = DDD emulated by HHH according to the semantics of the x86 language
Y = HHH never aborts its emulation of DDD
Z = DDD never stops running
>
I said: (X ∧ Y) ↔ Z
You said ~Y which entails ~Z just like I said.
>
I had to rewrite that a bunch of times.
>

>
But, that also means that you have agreed that this only hold is HHH doesn't EVER abort its emulaiton,

>
In the same way that
X = when you are starving hungry
Y = never eat
Z = you will die
(X ∧ Y) ↔ Z
remains true yet does not hold in the case of ~X ∨ ~Y.
>
You never actually refuted (X ∧ Y) ↔ Z
You simply started with ~Y.
>

>
Strawman, and category error.
>

 Not at all.

Simply LIE by you, note the "Category Error" is the comparison of:
  X = DDD emulated by HHH according to the semantics of the x86 language
  Y = HHH never aborts its emulation of DDD
  Z = DDD never stops running
to
  In the same way that
  X = when you are starving hungry
  Y = never eat
  Z = you will die
which are NOT comparable statements, as the first is about static immutable attributes of a program, and the second are transitory attributes of a living and changing being.

I claim (X ∧ Y) ↔ Z
and you provide the fake rebuttal of ~Y.
 

So, do you agree with my comments, or not. If not, what is ACTUALLY wrong with them
>

 I just told you how anyone knowing logic can see your mistake.

No, you are just proving to the world you are a LIAR.
I will take your change of topic to be your acceptance of the conditios I put on my answer and from now on DDD is only presumed to be non-halting when *THE* HHH in the problem NEVER aborts its emulation, and THAT is what is considered a "Correct Emulation by the semantics of the x86 processor", and you admit that you are lying when you claim that an HHH that aborts is correct at saying the correct emulation of DDD (which means *THIS* DDD, built on *THIS* HHH) will not reach a final state,
You also agree that "DDD" as in input includes ALL of the memory that holds ANY part of the code of the HHH that this DDD calls, and any claim that DIFFFERENT DDDs that call different HHHs are the "same" is just a lie.
LAST CALL on any disagreement on your stipulation of these FACTS.
Another side track will be considered your acceptance of this stipulation.

 

Failure to answer will be considered an admission that this is just another false claim of yours that you can not support, and my assertion is accepted by default.