On 8/18/24 8:51 AM, olcott wrote:

On 8/17/2024 7:29 AM, olcott wrote:

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)

*The essence of the above verbal claim is translated into logic*
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
(X ∧ Y) ↔ Z

x86utm takes the compiled Halt7.obj file of this c program https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

And thus the input to HHH isn't the bytes you try too pass off as it but
ALL of the code of Halt7.obj, so every HHH sees a DIFFERENT input so you
can't use the results of one to try to provide data for a different one
without making the mistake of talking about cats by looking at 10 story
office buildings.

This means that the ONLY HHH that the above applies to is when HHH is non-aborting, and every HHH that does abort, can't use that, as its DDD
doesn't call the needed HHH, but itself.

This means that DDD is Halting, if, and only if, HHH aborts its
emulation and returns, or DDD is non-halting, if, and only if, HHH NEVER
aborts its emulation.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/18/24 9:02 PM, olcott wrote:

On 8/18/2024 7:51 AM, olcott wrote:

On 8/17/2024 7:29 AM, olcott wrote:

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)

*The essence of the above verbal claim is translated into logic*
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
(X ∧ Y) ↔ Z

x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

All attempted rebuttals must take the form
of proving that (X ∧ Y) ↔ Z is not true

No, it is pointing out that by the precise terms of your claims, X can't happen, as there isn't a full DDD to emulate.

And, if you fix that, that the results only apply if in fact, *THE* HHH
never aborts its simulation, and we can't be thinking about two
different HHHs at a time, since they are in the same location of menory,

Thus, HHH can't claim that if was something it wasn't the input wouldn't
halt, as the input is only this input becuase HHH is what it is.

That this breaks your next steps, and thus you can't accept the
limitations just shows how broken your proof is,

IF we take you fix, which does require you rewording your claims, and
you can't accept the second restriction, that just proves that your full "proof" is just based on some invalid steps.

That we can be smart enough to see your error before you try to show it,
just shows how bad your lies are.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-18 12:51:20 +0000, olcott said:

On 8/17/2024 7:29 AM, olcott wrote:

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)

*The essence of the above verbal claim is translated into logic*
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
(X ∧ Y) ↔ Z

x86utm takes the compiled Halt7.obj file of this c program https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

What was wrong in V2?

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 8/19/24 7:50 AM, olcott wrote:

On 8/18/2024 8:15 PM, Richard Damon wrote:

On 8/18/24 9:02 PM, olcott wrote:

On 8/18/2024 7:51 AM, olcott wrote:

On 8/17/2024 7:29 AM, olcott wrote:

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)

*The essence of the above verbal claim is translated into logic*
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
(X ∧ Y) ↔ Z

x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

All attempted rebuttals must take the form
of proving that (X ∧ Y) ↔ Z is not true

No, it is pointing out that by the precise terms of your claims, X
can't happen, as there isn't a full DDD to emulate.

You are simply ignoring one of the premises.

No, I am showing that it isn't in fact the HHH that you are going to
talk about, If it was, you wouldn't mind the stiulation.

And, if you fix that, that the results only apply if in fact, *THE*
HHH never aborts its simulation, and we can't be thinking about two
different HHHs at a time, since they are in the same location of menory,

Yes this is the HHH.

And thus the only HHHx that exists for a given DDDy is the case where
x=y, and thus the only input to HHHn is DDDn and only HHH∞ has been
proven to create a non-halting DDD, not any other HHHn, and thus your
LIE is exposed.

Thus, HHH can't claim that if was something it wasn't the input
wouldn't halt, as the input is only this input becuase HHH is what it is.

void EEE()
{
  HERE: goto HERE;
}

HHHn predicts the behavior of DDD∞ the same
way that HHHn predicts the behavior of EEE∞.

But can't for DDD∞ because it can't be given it, only DDDn.


THAT is your LIE.

That this breaks your next steps, and thus you can't accept the
limitations just shows how broken your proof is,

IF we take you fix, which does require you rewording your claims, and
you can't accept the second restriction, that just proves that your
full "proof" is just based on some invalid steps.

That we can be smart enough to see your error before you try to show
it, just shows how bad your lies are.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-19 01:02:08 +0000, olcott said:

On 8/18/2024 7:51 AM, olcott wrote:

On 8/17/2024 7:29 AM, olcott wrote:

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)

*The essence of the above verbal claim is translated into logic*
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
(X ∧ Y) ↔ Z

x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

All attempted rebuttals must take the form
of proving that (X ∧ Y) ↔ Z is not true

I think most readres would regard sufficient if the relevanse of
that formula to anyting interesting is not shown.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

On 2024-08-19 01:15:01 +0000, Richard Damon said:

On 8/18/24 9:02 PM, olcott wrote:

On 8/18/2024 7:51 AM, olcott wrote:

On 8/17/2024 7:29 AM, olcott wrote:

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)

*The essence of the above verbal claim is translated into logic*
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
(X ∧ Y) ↔ Z

x86utm takes the compiled Halt7.obj file of this c program
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Thus making all of the code of HHH directly available to
DDD and itself. HHH emulates itself emulating DDD.

All attempted rebuttals must take the form
of proving that (X ∧ Y) ↔ Z is not true

No, it is pointing out that by the precise terms of your claims, X
can't happen, as there isn't a full DDD to emulate.

Nvertheless, it Z is false then (X ∧ Y) ↔ Z is still true.

--
Mikko

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)