Re: DDD emulated by HHH --- (does not refer to prior posts)

Op 04.sep.2024 om 15:17 schreef olcott:

On 9/4/2024 4:56 AM, Fred. Zwarts wrote:

Op 03.sep.2024 om 15:58 schreef olcott:

On 9/3/2024 3:52 AM, Mikko wrote:

On 2024-09-02 13:31:23 +0000, olcott said:
>

On 9/1/2024 6:05 AM, Mikko wrote:

On 2024-08-31 16:18:26 +0000, olcott said:
>

On 8/31/2024 10:49 AM, Fred. Zwarts wrote:

Op 31.aug.2024 om 17:19 schreef olcott:

On 8/31/2024 9:59 AM, Fred. Zwarts wrote:

Op 31.aug.2024 om 14:03 schreef olcott:

On 8/31/2024 4:07 AM, Fred. Zwarts wrote:

Op 30.aug.2024 om 16:58 schreef olcott:

On 8/30/2024 9:56 AM, joes wrote:

Am Thu, 29 Aug 2024 09:07:39 -0500 schrieb olcott:

On 8/29/2024 2:17 AM, Mikko wrote:

On 2024-08-28 12:08:06 +0000, olcott said:

On 8/28/2024 2:39 AM, Mikko wrote:

On 2024-08-27 12:44:31 +0000, olcott said:

On 8/27/2024 3:38 AM, Fred. Zwarts wrote:

Op 27.aug.2024 om 04:33 schreef olcott:

This is intended to be a stand-alone post that does not reference
anything else mentioned in any other posts.
_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]
>
When we assume that:
(a) HHH is an x86 emulator that is in the same memory space as
DDD. (b) HHH emulates DDD according to the semantics of the x86
language.
then we can see that DDD emulated by HHH cannot possibly get past
its own machine address 0000217a.
>

Yes, we see. In fact DDD is not needed at all.

https://en.wikipedia.org/wiki/Straw_man

You should also point a link to the equivocation fallacy. You use it
more often than straw man.

Isomorphism is not equivocation

The use of HHH for many purposes (a specific program, an unpsecified
memeber of a set of programs, a hypothetical program) is.
Your first posting looked like you were going to apply equivocation
later in the discussion. Now, after several later messages, it seems
that you want to apply the fallacy of "moving the goal posts" instead.
>

HHH correctly predicts what the behavior of DDD would be if this HHH
never aborted its emulation of DDD.

Problem is, DDD is then not calling itself, but the non- input of a
not-aborting HHH.
>

>
*This is before any aborting occurs*
*This is before any aborting occurs*
*This is before any aborting occurs*

>
Here is your problem. The code of the program and its meaning according to the semantics of the x86 language, does not suddenly change when the aborting occurs.

>
You cannot possibly say one damn thing about the behavior of DDD
until you first understand that a world class x86 emulator that
HHH calls does enable HHH to correctly emulate itself emulating
DDD and the following execution trace proves this.
>

>
And when this unmodified world class x86 simulator was given olcott's DDD based on the aborting HHH as input, it showed that this has halting behaviour.
THIS IS A VERIFIED FACT! Even olcott has verified it.
This correct simulation by the unmodified world class simulator tells us that the program has a halting behaviour.
Your *modification* of the simulator stops the simulation before it can see the halting behaviour and decides that the input is non- halting.
We know which one is correct: the unmodified world class simulator, not the *modified* one, which aborts one cycle too soon..
>
SO, it it not honest to suggest that we do not understand what the world class simulator predicts.
>

SE CANNOT POSSIBLY HAVE ANY HONEST DIALOGUE WHEN MY REVIEWERS
INSIST ON LYING ABOUT VERIFIED FACTS.

>
No evidence given. No reference to a single lie.
Olcott seems just a bit short of memory.
It is unclear why olcott hides these verified fact, which he knows are true.
>

>
_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]
>
_main()
[00002192] 55         push ebp
[00002193] 8bec       mov ebp,esp
[00002195] 6872210000 push 00002172 ; push DDD
[0000219a] e833f4ffff call 000015d2 ; call HHH(DDD)
[0000219f] 83c404     add esp,+04
[000021a2] 50         push eax
[000021a3] 6843070000 push 00000743
[000021a8] e8b5e5ffff call 00000762
[000021ad] 83c408     add esp,+08
[000021b0] 33c0       xor eax,eax
[000021b2] 5d         pop ebp
[000021b3] c3         ret
Size in bytes:(0034) [000021b3]
>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002192][00103820][00000000] 55         push ebp      ; Begin main()
[00002193][00103820][00000000] 8bec       mov ebp,esp   ; housekeeping
[00002195][0010381c][00002172] 6872210000 push 00002172 ; push DDD
[0000219a][00103818][0000219f] e833f4ffff call 000015d2 ; call HHH(DDD)
>
New slave_stack at:1038c4
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138cc
[00002172][001138bc][001138c0] 55         push ebp      ; housekeeping
[00002173][001138bc][001138c0] 8bec       mov ebp,esp   ; housekeeping
[00002175][001138b8][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][001138b4][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
New slave_stack at:14e2ec
[00002172][0015e2e4][0015e2e8] 55         push ebp      ; housekeeping
[00002173][0015e2e4][0015e2e8] 8bec       mov ebp,esp   ; housekeeping
[00002175][0015e2e0][00002172] 6872210000 push 00002172 ; push DDD
[0000217a][0015e2dc][0000217f] e853f4ffff call 000015d2 ; call HHH(DDD)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>
>

Still dreaming of the HHH that does an infinite recursion?

>
Before we can proceed to the next step you must first agree
that the second emulation of DDD by the emulated HHH is proven
to be correct on the basis that it does emulate the first four
instructions of DDD.
>

>
I agree that the simulation makes a good start, but it fails to complete the simulation up to the end, making the simulation as a whole incorrect.
We cannot proceed before you understand this.

>
Here is no abort and x86utm emulating 100,000,000 instructions.

>
What happens after those 100 000 000 instructions are executed?
>

>
I just showed you what happens immediately below. It shows
that 100,000,000 million instructions were executed and the
full trace requires 1,492,537 Pages.

>
But does not abort the exectuion?
>

>
_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]
>
Anyone that is not dumber than a box of rocks can tell
that machine address 0000217f is unreachable for every
DDD emulated by HHH according to the semantics of the
x86 language where HHH emulates itself emulating DDD.

>
And only Olcott does not realise that this means that HHH fails to do a correct simulation. A correct simulation must reach the end of a halting program.

 That is not what the x86 source code says.
The x86 source code says it is not allowed to do this.
The x86 source code tells DDD to keep repeating
it first four instructions endlessly until DDD
stops emulating any of the x86 instructions of DDD.

That is olcott's error.
The finite string given to HHH specifies (just like the source code) that HHH will see a 'special condition' after two cycles. Than HHH will return to DDD and DDD will halt. Two recursions is not endlessly. Endlessly is just your dream, not what the code specifies.
When HHH stops simulating, it misses this part of the code, because it stops too soon.

 There is no freaking way that any DDD correctly
emulated by any HHH can possibly reach its own
machine address 0000217f.

Exactly! That is because HHH prevents DDD to go far enough. One cycle later DDD would have halted.
HHH should simulate one cycle more that it is programmed to do, but, of course, it is impossible to find a number that is greater than itself, so there is no correct number of cycles to simulate.
HHH cannot possibly simulate itself correctly up to the end.

 HHH could incorrectly emulate DDD and decide to
simply ignore machine address 0000217a.

That would be wrong as well.
There is no way to correct HHH.
HHH cannot possibly simulate itself correctly up to the end.

 The only way for HHH to emulate DDD to machine
address 0000217f is for HHH to disagree with the x86
language and ignore the instruction as machine address
0000217a that it is not allowed to ignore.
 

That would be wrong as well, because it is just another violation of the semantics of the x86 language.
There is no way to correct HHH.
HHH cannot possibly simulate itself correctly up to the end.
Olcott keeps trying to fix the problems in HHH, but (against all evidence) he refuses to accept that there is no way to fix HHH.
HHH cannot possibly simulate itself correctly up to the end.