On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see. Of course, because the traces are
incomplete it is possible to see a pattern that actually is not
there. But does that really happen?

--
Mikko

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

Op 30.jul.2024 om 16:21 schreef olcott:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line [0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line [0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line [0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line [0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH [00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line [0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

We all see the differences between these two. In the first one, the call
refers to the start 0000215a, so, that one indeed is a complete recursion.
But in the second one the call does not refer to the start: 00001567 is
not 00002177. So, that is not a complete cycle. The call of the second
one refers to HHH. The cycle is complete, when also HHH is simulated.
The semantics of the x86 language, which is apparently ignored here,
requires the continuation with the instructions in HHH, which *does*
have conditional branch instructions.
So, olcott is cheating by comparing these two and claiming that there
are no conditional branch instructions. The conditional branch
instructions are hidden in HHH, which olcott does not want to show here, because it would make his error too obvious.
The second one looks more like Finite_Recursion.
The infinite recursion exists only in Olcott's dreams, which are no
substitute for logic.

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

On 7/30/24 10:21 AM, olcott wrote:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line [0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line [0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line [0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line [0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH

But this is an incorrect emulation, proving you are just a stupid liar.

emulation of the "Call 000015d7" must be followed by the emulation of
the code at 00-0015d7.

If it isn't part of the input, then the input just isn't a correct representation of the program and you are also show to be a liar.

[00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line [0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

And, if you say that HHH knows that 000015d7 is the address of an
emulator, then you also are a liar, because it isn't, it is a decider
that only CONDITIONALLY emulates the input, and thus can not be
correctly replaced by ANY valid definition of emulation with the code
that it is conditionally emulating.

Sorry, you are just proving that you are nothing but a stupid liar, as everything you say is based on your lies.

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

On 2024-07-30 14:21:02 +0000, olcott said:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation Execution Trace Stored at:113934 [0000215a][00113924][00113928] 55 push ebp ; 1st line [0000215b][00113924][00113928] 8bec mov ebp,esp ; 2nd line [0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line [0000215a][0011391c][00113924] 55 push ebp ; 1st line [0000215b][0011391c][00113924] 8bec mov ebp,esp ; 2nd line [0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation Execution Trace Stored at:113895 [00002177][00113885][00113889] 55 push ebp ; 1st line [00002178][00113885][00113889] 8bec mov ebp,esp ; 2nd line [0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH [00002177][0015e2ad][0015e2b1] 55 push ebp ; 1st line [00002178][0015e2ad][0015e2b1] 8bec mov ebp,esp ; 2nd line [0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD [0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

As that part does not show the anwer it seems best to assume that they
do not see the same pattern or the pattern is not a real non-halting
behaviour pattern. Of course, if a proof is ever presented, we may need
to reconsider, but it is very unlikely that any such proof will ever
be presented.

--
Mikko

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

On 2024-07-31 07:42:42 +0000, Mikko said:

On 2024-07-30 14:21:02 +0000, olcott said:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation Execution Trace Stored at:113934
[0000215a][00113924][00113928] 55 push ebp ; 1st line
[0000215b][00113924][00113928] 8bec mov ebp,esp ; 2nd line
[0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55 push ebp ; 1st line
[0000215b][0011391c][00113924] 8bec mov ebp,esp ; 2nd line
[0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation Execution Trace Stored at:113895
[00002177][00113885][00113889] 55 push ebp ; 1st line
[00002178][00113885][00113889] 8bec mov ebp,esp ; 2nd line
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
[00002177][0015e2ad][0015e2b1] 55 push ebp ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec mov ebp,esp ; 2nd line
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

As that part does not show the anwer it seems best to assume that they
do not see the same pattern or the pattern is not a real non-halting behaviour pattern. Of course, if a proof is ever presented, we may need
to reconsider, but it is very unlikely that any such proof will ever
be presented.

Forgot to mention that the above traces confirm one thing: they are
incomplete. At least relevant register values should be shown.

--
Mikko

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

On 2024-07-31 17:31:27 +0000, olcott said:

On 7/31/2024 2:48 AM, Mikko wrote:

On 2024-07-31 07:42:42 +0000, Mikko said:

On 2024-07-30 14:21:02 +0000, olcott said:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 >>>> [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line >>>> [0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line >>>> [0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 >>>> [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line >>>> [0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
[00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line >>>> [0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

As that part does not show the anwer it seems best to assume that they
do not see the same pattern or the pattern is not a real non-halting
behaviour pattern. Of course, if a proof is ever presented, we may need
to reconsider, but it is very unlikely that any such proof will ever
be presented.

Forgot to mention that the above traces confirm one thing: they are
incomplete. At least relevant register values should be shown.

This algorithm is used by all the simulating termination analyzers:
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
If *simulating halt decider H correctly simulates its input D*
*until H correctly determines that its simulated D would never*
*stop running unless aborted* then

H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

In other words you persistently insist on dishonestly
providing a fake rebuttal that has already been fully refuted.

As everyone can see, Sipser does not disagree with my observations.
As for rebuttals, it sufficent to note that Olcott has not rebutted
anyhing.

--
Mikko

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

On 2024-07-31 16:07:34 +0000, olcott said:

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

On 2024-07-30 14:21:02 +0000, olcott said:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 >>> [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line >>> [0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line >>> [0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 >>> [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line >>> [0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
[00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line >>> [0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

As that part does not show the anwer it seems best to assume that they
do not see the same pattern or the pattern is not a real non-halting
behaviour pattern. Of course, if a proof is ever presented, we may need
to reconsider, but it is very unlikely that any such proof will ever
be presented.

A proof is any sequence of steps such that the conclusion
is a necessary consequence of its basis.

Proving that DDD correctly emulated by HHH matches the
infinite recursion behavior pattern.
(a) The semantics of the x86 language.
(b) the design of HHH provided below.
(c) The definition of infinite recursion provided below.

*Infinite recursion behavior pattern*
An emulated sequence of instructions that has no conditional
branch instructions in this sequence is exactly repeated when
it calls the same function with the same parameters again.
As long as the called function can be determined to never
return this proves infinite recursion.

You have not proven that there is no conditional instructions
in the repeated cycle.

HHH continues to emulate DDD until DDD halts* or DDD proves
that it must be aborted.

In particular, you must prove that this determination does
not involve any conditional instructions.

This proves that no emulated HHH can
possibly return to any emulated DDD, thus DDD never *halts.

It does not prove anything as long as it is unproven itself.

*Halts terminates normally by reaching its own "ret" instruction.

Not the "halts" of the Halting Problem. A halting computation is one
that specifies a sequence of "configurations" (sensu Lintzi) so that
everyone except the first is the result of application of the rules
to the previous state and the last one is one where no rule is applicable.

--
Mikko

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

On 8/2/24 1:42 PM, olcott wrote:

On 8/2/2024 4:55 AM, Mikko wrote:

On 2024-07-31 16:07:34 +0000, olcott said:

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

On 2024-07-30 14:21:02 +0000, olcott said:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 >>>>> [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 >>>>> [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
[00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

As that part does not show the anwer it seems best to assume that they >>>> do not see the same pattern or the pattern is not a real non-halting
behaviour pattern. Of course, if a proof is ever presented, we may need >>>> to reconsider, but it is very unlikely that any such proof will ever
be presented.

A proof is any sequence of steps such that the conclusion
is a necessary consequence of its basis.

Proving that DDD correctly emulated by HHH matches the
infinite recursion behavior pattern.
(a) The semantics of the x86 language.
(b) the design of HHH provided below.
(c) The definition of infinite recursion provided below.

*Infinite recursion behavior pattern*
An emulated sequence of instructions that has no conditional
branch instructions in this sequence is exactly repeated when
it calls the same function with the same parameters again.
As long as the called function can be determined to never
return this proves infinite recursion.

You have not proven that there is no conditional instructions
in the repeated cycle.

void DDD()
{
  HHH(DDD);
  return;
}

In other words you are too damn stupid to see that
DDD correctly emulated by HHH cannot possibly reach
its own return instruction?

No, you are too stupid to realize that your HHH doesn't actually
correctly emulates DDD, and it doesn't matter what some other HHH that
creates a different DDD does.

This seems to be because you are just totally ignorant about what a
"program", the sort of thing you can ask about it halting, actually is.

Sorry, you are just too stupid to understand your own stupidity.

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

On 2024-08-02 17:42:47 +0000, olcott said:

On 8/2/2024 4:55 AM, Mikko wrote:

On 2024-07-31 16:07:34 +0000, olcott said:

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

On 2024-07-30 14:21:02 +0000, olcott said:

On 7/30/2024 1:52 AM, Mikko wrote:

On 2024-07-29 14:07:53 +0000, olcott said:

HHH(Infinite_Recursion) and HHH(DDD) show the same non-halting
behavior pattern in their derived execution traces of their
inputs.

Hard to believe as their behaviour is so different and you don't
say what pattern the see.

*Its all in the part that you erased*

*Infinite_Recursion correctly emulated by HHH*
*THREE lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113934 >>>>> [0000215a][00113924][00113928] 55         push ebp      ; 1st line
[0000215b][00113924][00113928] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113920][00002162] e8f8ffffff call 0000215a ; 3rd line
[0000215a][0011391c][00113924] 55         push ebp      ; 1st line
[0000215b][0011391c][00113924] 8bec       mov ebp,esp   ; 2nd line
[0000215d][00113918][00002162] e8f8ffffff call 0000215a ; 3rd line
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

*DDD correctly emulated by HHH*
*FOUR lines repeat with no conditional branch instructions*
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895 >>>>> [00002177][00113885][00113889] 55         push ebp      ; 1st line
[00002178][00113885][00113889] 8bec       mov ebp,esp   ; 2nd line
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
[00002177][0015e2ad][0015e2b1] 55         push ebp      ; 1st line
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp   ; 2nd line
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

As that part does not show the anwer it seems best to assume that they >>>> do not see the same pattern or the pattern is not a real non-halting
behaviour pattern. Of course, if a proof is ever presented, we may need >>>> to reconsider, but it is very unlikely that any such proof will ever
be presented.

A proof is any sequence of steps such that the conclusion
is a necessary consequence of its basis.

Proving that DDD correctly emulated by HHH matches the
infinite recursion behavior pattern.
(a) The semantics of the x86 language.
(b) the design of HHH provided below.
(c) The definition of infinite recursion provided below.

*Infinite recursion behavior pattern*
An emulated sequence of instructions that has no conditional
branch instructions in this sequence is exactly repeated when
it calls the same function with the same parameters again.
As long as the called function can be determined to never
return this proves infinite recursion.

You have not proven that there is no conditional instructions
in the repeated cycle.

void DDD()
{
HHH(DDD);
return;
}

In other words you are too damn stupid to see that
DDD correctly emulated by HHH cannot possibly reach
its own return instruction?

I can see perfectly well that DDD cannot reach its return instruction
if HHH fails to return. Whether HHH fails to return is your problem,
not mine.

--
Mikko

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