Op 26.jul.2024 om 03:49 schreef olcott:

If you understand the x86 language and can't tell how DDD
emulated by HHH differs from DDD emulated by HHH1 by the
following then you are probably lying about understanding
the x86 language.

We understand it perfectly. HHH cannot possibly simulate itself correctly.
HH1 does a correct simulation, but HHH does an incomplete and therefore incorrect simulation. The incomplete simulation does not show the full behaviour of DDD.
Since skipping x86 code is against the semantics of the x86 language, it
is clear where the error is.

*I did annotate it a little better this time*

typedef void (*ptr)();
int HHH(ptr P);
int HHH1(ptr P);

void DDD()
{
  HHH(DDD);
}

int main()
{
  HHH1(DDD);
}

*You really don't need to know one damn thing else besides this*
*You really don't need to know one damn thing else besides this*
*You really don't need to know one damn thing else besides this*

All that you have to know is that HHH and HHH1 are x86 emulators
and that HHH sees that same repeated state (first four lines of DDD)
that anyone knowing the x86 language can see.

_DDD()
[00002177] 55         push ebp
[00002178] 8bec       mov ebp,esp
[0000217a] 6877210000 push 00002177 ; push DDD
[0000217f] e853f4ffff call 000015d7 ; call HHH
[00002184] 83c404     add esp,+04
[00002187] 5d         pop ebp
[00002188] c3         ret
Size in bytes:(0018) [00002188]

_main()
[00002197] 55         push ebp
[00002198] 8bec       mov ebp,esp
[0000219a] 6877210000 push 00002177 ' push DDD
[0000219f] e863f3ffff call 00001507 ; call HH1
[000021a4] 83c404     add esp,+04
[000021a7] 33c0       xor eax,eax
[000021a9] 5d         pop ebp
[000021aa] c3         ret
Size in bytes:(0020) [000021aa]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00002197][001037fb][00000000] 55         push ebp [00002198][001037fb][00000000] 8bec       mov ebp,esp [0000219a][001037f7][00002177] 6877210000 push 00002177 ; push DDD [0000219f][001037f3][000021a4] e863f3ffff call 00001507 ; call HHH1
New slave_stack at:10389f

// emulates 1st instance of DDD that calls HHH(DDD)
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138a7 [00002177][00113897][0011389b] 55         push ebp [00002178][00113897][0011389b] 8bec       mov ebp,esp [0000217a][00113893][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0011388f][00002184] e853f4ffff call 000015d7 ; call HHH
New slave_stack at:14e2c7

// emulates 2nd instance of DDD that calls HHH(DDD)
Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2cf [00002177][0015e2bf][0015e2c3] 55         push ebp [00002178][0015e2bf][0015e2c3] 8bec       mov ebp,esp [0000217a][0015e2bb][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0015e2b7][00002184] e853f4ffff call 000015d7 ; call HHH
New slave_stack at:198cef

// emulates 3rd instance of DDD that calls HHH(DDD) [00002177][001a8ce7][001a8ceb] 55         push ebp [00002178][001a8ce7][001a8ceb] 8bec       mov ebp,esp [0000217a][001a8ce3][00002177] 6877210000 push 00002177 ; push DDD [0000217f][001a8cdf][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

This is the error in HHH. HHH is programmed to print after two cycles
that there is an infinite recursion, which is not true, after which it
aborts and halts, making the simulation incorrect.

HHH is simply unable to decide about finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect. It does not see the difference between an finite and an
infinite recursion.

// returns to 1st instance of DDD emulated by HHH1 [00002184][00113897][0011389b] 83c404     add esp,+04 [00002187][0011389b][000015bc] 5d         pop ebp [00002188][0011389f][0003a980] c3         ret

// return to main
[000021a4][001037fb][00000000] 83c404     add esp,+04 [000021a7][001037fb][00000000] 33c0       xor eax,eax [000021a9][001037ff][00000018] 5d         pop ebp [000021aa][00103803][00000000] c3         ret
Number of Instructions Executed(352831) == 5266 Pages

Olcott's psychology is intriguing. At the one hand he is crying for
help. He has some ideas which he cannot prove. Therefore he is begging
the exports to help him with a proof.
When the experts prove that there are errors in his idea and show him a
way to improve his idea, he does not have the mental intelligence to
even consider the possibility that there is something incorrect in his
ideas. He cannot show any error in their proofs, but he does not want to
accept it.
Therefore he uses the excuse that the experts must be lying in order to
be able to ignore the proofs that his ideas are wrong.
Then he keeps repeating his proven incorrect ideas, without any
evidence, probably hoping that if it is repeated often enough, it will
become true.
That is not how logic works.
No matter how much olcott wants it to be correct, or how many times
olcott repeats that it is correct, it does not change the fact that
these ideas are incorrect.

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

On 2024-07-26 01:49:46 +0000, olcott said:

If you understand the x86 language and can't tell how DDD
emulated by HHH differs from DDD emulated by HHH1 by the
following then you are probably lying about understanding
the x86 language.

*I did annotate it a little better this time*

typedef void (*ptr)();
int HHH(ptr P);
int HHH1(ptr P);

void DDD()
{
HHH(DDD);
}

int main()
{
HHH1(DDD);
}

*You really don't need to know one damn thing else besides this*
*You really don't need to know one damn thing else besides this*
*You really don't need to know one damn thing else besides this*

All that you have to know is that HHH and HHH1 are x86 emulators
and that HHH sees that same repeated state (first four lines of DDD)
that anyone knowing the x86 language can see.

The first state of DDD is not repeated in the same execution. Another
exection may see the same states and at least sees the same initial
state but that is not called a repeated state. A repeated state is a
state that has alredy occurred in the same execution.

--
Mikko

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

On 2024-07-26 13:17:19 +0000, olcott said:

On 7/26/2024 3:42 AM, Mikko wrote:

On 2024-07-26 01:49:46 +0000, olcott said:

If you understand the x86 language and can't tell how DDD
emulated by HHH differs from DDD emulated by HHH1 by the
following then you are probably lying about understanding
the x86 language.

Any emulation of DDD that differs from DDD is wrong.

If the emulation of DDD by HHH differs from the emulation of DDD by HHH1
then at least one of them differes from DDD and is wrong.

*I did annotate it a little better this time*

typedef void (*ptr)();
int HHH(ptr P);
int HHH1(ptr P);

void DDD()
{
   HHH(DDD);
}

int main()
{
   HHH1(DDD);
}

*You really don't need to know one damn thing else besides this*
*You really don't need to know one damn thing else besides this*
*You really don't need to know one damn thing else besides this*

All that you have to know is that HHH and HHH1 are x86 emulators
and that HHH sees that same repeated state (first four lines of DDD)
that anyone knowing the x86 language can see.

No knowledge of x86 is necessary as no x86 code is shown above.
From C semantics it is obvious that DDD returns if and only if
HHH(DDD) returns.

Whther DDD returns can be checked with

int main()
{
   DDD();
}

If this main returns it proves that there is no non-halting pattern in DDD.
If HHH finds one there it is wrong.

--
Mikko

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

Op 27.jul.2024 om 16:15 schreef olcott:

On 7/27/2024 2:42 AM, Mikko wrote:

On 2024-07-26 13:17:19 +0000, olcott said:

On 7/26/2024 3:42 AM, Mikko wrote:

On 2024-07-26 01:49:46 +0000, olcott said:

If you understand the x86 language and can't tell how DDD
emulated by HHH differs from DDD emulated by HHH1 by the
following then you are probably lying about understanding
the x86 language.

Any emulation of DDD that differs from DDD is wrong.

OK so you are lying about knowing the x86 language
or don't bother to study the execution trace well enough.

_Infinite_Recursion()
[0000215a] 55               push ebp
[0000215b] 8bec             mov ebp,esp
[0000215d] e8f8ffffff       call 0000215a ; recursive call
[00002162] 5d               pop ebp
[00002163] c3               ret
Size in bytes:(0010) [00002163]

Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 Decide_Halting_HH:1
[0000215a][00113924][00113928] 55               push ebp [0000215b][00113924][00113928] 8bec             mov ebp,esp [0000215d][00113920][00002162] e8f8ffffff       call 0000215a [0000215a][0011391c][00113924] 55               push ebp [0000215b][0011391c][00113924] 8bec             mov ebp,esp [0000215d][00113918][00002162] e8f8ffffff       call 0000215a
Local Halt Decider: *Infinite Recursion Detected Simulation Stopped*

If you can't understand how the above proves infinite recursion
you won't be able to understand how DDD correctly emulated by HHH
proves recursive simulation. It is the same non-halting behavior
pattern in both cases.

Since HHH does not know that DDD is calling itself HHH only
sees infinite recursion and not does not recursive simulation.

_DDD()
[00002177] 55         push ebp
[00002178] 8bec       mov ebp,esp
[0000217a] 6877210000 push 00002177 ; push DDD
[0000217f] e853f4ffff call 000015d7 ; call HHH
[00002184] 83c404     add esp,+04
[00002187] 5d         pop ebp
[00002188] c3         ret
Size in bytes:(0018) [00002188]

_main()
[00002197] 55         push ebp
[00002198] 8bec       mov ebp,esp
[0000219a] 6877210000 push 00002177 ' push DDD
[0000219f] e863f3ffff call 00001507 ; call HH1
[000021a4] 83c404     add esp,+04
[000021a7] 33c0       xor eax,eax
[000021a9] 5d         pop ebp
[000021aa] c3         ret
Size in bytes:(0020) [000021aa]

 machine   stack     stack     machine    assembly
 address   address   data      code       language
 ========  ========  ========  =========  ============= [00002197][001037fb][00000000] 55         push ebp [00002198][001037fb][00000000] 8bec       mov ebp,esp [0000219a][001037f7][00002177] 6877210000 push 00002177 ; push DDD [0000219f][001037f3][000021a4] e863f3ffff call 00001507 ; call HHH1
New slave_stack at:10389f

// emulates 1st instance of DDD that calls HHH(DDD)
Begin Local Halt Decider Simulation   Execution Trace Stored at:1138a7 [00002177][00113897][0011389b] 55         push ebp [00002178][00113897][0011389b] 8bec       mov ebp,esp [0000217a][00113893][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0011388f][00002184] e853f4ffff call 000015d7 ; call HHH
New slave_stack at:14e2c7

// emulates 2nd instance of DDD that calls HHH(DDD)
Begin Local Halt Decider Simulation   Execution Trace Stored at:15e2cf [00002177][0015e2bf][0015e2c3] 55         push ebp [00002178][0015e2bf][0015e2c3] 8bec       mov ebp,esp [0000217a][0015e2bb][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0015e2b7][00002184] e853f4ffff call 000015d7 ; call HHH
New slave_stack at:198cef

// emulates 3rd instance of DDD that calls HHH(DDD) [00002177][001a8ce7][001a8ceb] 55         push ebp [00002178][001a8ce7][001a8ceb] 8bec       mov ebp,esp [0000217a][001a8ce3][00002177] 6877210000 push 00002177 ; push DDD [0000217f][001a8cdf][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: *Infinite Recursion Detected Simulation Stopped*

The programmer made this HHH to print an invalid message. It seems that
the programmer does not understand the difference between two recursions
and an infinite recursion.

HHH is simply unable to decide about comparable finite recursions.

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

It decides after N recursions that there is an infinite recursion, which
is incorrect.

HHH is coded to abort after two recursions, so there is no infinite
recursion. It is only olcott dreaming of an infinite recursion in
another HHH.

// returns to 1st instance of DDD emulated by HHH1 [00002184][00113897][0011389b] 83c404     add esp,+04 [00002187][0011389b][000015bc] 5d         pop ebp [00002188][0011389f][0003a980] c3         ret

// return to main
[000021a4][001037fb][00000000] 83c404     add esp,+04 [000021a7][001037fb][00000000] 33c0       xor eax,eax [000021a9][001037ff][00000018] 5d         pop ebp [000021aa][00103803][00000000] c3         ret
Number of Instructions Executed(352831) == 5266 Pages

This is the exact same pattern with Infinite_Recursion()
where there are no conditional branch instructions that
would prevent the first three instructions of
Infinite_Recursion() from endlessly repeating.

No, it is the same as

void Finite_Recursion (int N) {
if (N > 0) Finite_Recursion (N - 1);
}

The conditional branch instructions are in HHH, which aborts after two recursions.

DDD is a misleading and unneeded complication. It is easy to eliminate DDD:

int main() {
return HHH(main);
}

This has the same problem. This proves that the problem is not in DDD,
but in HHH, which halts when it aborts the simulation, but it decides
that the simulation of itself does not halt.
It shows that HHH cannot possibly simulate itself correctly.

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

On 2024-07-27 14:15:21 +0000, olcott said:

On 7/27/2024 2:42 AM, Mikko wrote:

On 2024-07-26 13:17:19 +0000, olcott said:

On 7/26/2024 3:42 AM, Mikko wrote:

On 2024-07-26 01:49:46 +0000, olcott said:

If you understand the x86 language and can't tell how DDD
emulated by HHH differs from DDD emulated by HHH1 by the
following then you are probably lying about understanding
the x86 language.

Any emulation of DDD that differs from DDD is wrong.

OK so you are lying about knowing the x86 language
or don't bother to study the execution trace well enough.

The latter. Your execution traces are incomplete so it is not possible
to study them well enough. For example, after each instruction the
contentents of the changed registers should be shown.

Even without a detailed analysis of the traces it is easy to see that
you have not proven your claims. In particular, most of the trace lines
are not quoted in a sentence, which means that you have not proven anyting about them, and in particular neither that they cause the termination of
the computation specified by the input nor that they do nor cause.

--
Mikko

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