Re: 197 page execution trace of DDD correctly simulated by HHH

On 7/2/2024 6:30 AM, Richard Damon wrote:

On 7/1/24 11:34 PM, olcott wrote:

On 7/1/2024 10:21 PM, Richard Damon wrote:

On 7/1/24 11:14 PM, olcott wrote:

On 7/1/2024 9:44 PM, Richard Damon wrote:

On 7/1/24 10:34 PM, olcott wrote:

On 7/1/2024 9:24 PM, Richard Damon wrote:

On 7/1/24 9:36 PM, olcott wrote:

On 7/1/2024 7:38 PM, Richard Damon wrote:

On 7/1/24 8:59 AM, olcott wrote:

On 7/1/2024 3:23 AM, Fred. Zwarts wrote:

Op 30.jun.2024 om 19:20 schreef olcott:

>
_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 cannot possibly return, because HHH aborts itself one cycle too early, showing that the emulation is incorrect. If that is over your head, try to learn how x86 instructions work.

>
_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]
>
DDD is correctly emulated by HHH which calls an
emulated HHH(DDD) to repeat the process until aborted.
>
>

>
CAN'T BE.
>
A "Correct Emulation" is one that produces the same result as the program at the input.
>

>
Which can only possibly occur be disregarding the semantics
of the x86 language. Liars would do that ignoramuses would do
that. Everyone with the equivalent of a BSCS would know that
what I said is true.
>
>

>
Why do you say that? That is EXACTLY the definition of Correct Emulation.

>
>
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.
WELL INDOCTRINATED FALSE ASSUMPTIONS ARE NOT TRUTH.

>
And denying definitions is just lying.

>
It may seem that way when you don't bother to pay
attention that this definition is contradicted
by verified facts.

>
WHAT "Verified facts".
>
THe fact that DDD will halt since your HHH(DDD) retuns?
>

>
Indoctrination will cause this. The only cure is
correct reasoning by assuming that everything that
anyone ever told you about anything is possibly
false until conclusively proven otherwise.

>
Nope, but failure to follow the defined rules gets you kick out of the club.
>

>
If everyone always did this then Nazi propaganda
could not possibly have any chance of success.

>
But THEY Lied, and to could be shown so,
>
Just like your statements.
>

>

>
void Infinite_Loop()
{
   HERE: goto HERE;
}
>
void Infinite_Recursion()
{
   Infinite_Recursion();
}
>
void DDD()
{
   HHH(DDD);
}
>
Every C programmer that knows what an x86 emulator is knows
that when HHH emulates the machine language of Infinite_Loop, Infinite_Recursion, and DDD that it must abort these emulations
so that itself can terminate normally.
>
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
SO THESE THREE INPUTS DO NOT FREAKING HALT
>

>
No, DDD does halt if HHH is a decider and HHH(DDD) returns.
>

>
That is the same nutty bullshit as Gödel's 1931 incompleteness
theorem. If there are no truth preserving operations in PA to
either G or ~G then G has no truthmaker in PA making G not a
truth-bearer in PA.

>
But there ARE a set of truth preserving operations in PA to show G, it is just that it takes an infinite number of them, so they don't constitute a proof.
>

>
Diagonalization conclusively proves otherwise and you know it.
Maybe the issue is that you are fundamentally a liar.
>
>

 How?
 I call your bluff, show your "cards" or FOLD.
 

That is not the way it works, you made a false claim and I
call your bluff on this false claim. You must provide a linked
source that agrees.
 >>> But there ARE a set of truth preserving operations in PA to show G,
 >>> it is just that it takes an infinite number of them, so they don't
 >>> constitute a proof.
*This source says nothing like what you claim*
https://plato.stanford.edu/entries/goedel-incompleteness/#FirIncTheCom
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer