Re: DIFFERENT LEVELS OF RECURSION --- DD specifies non-terminating behavior to HHH

On 2/15/25 10:33 PM, olcott wrote:

On 2/14/2025 7:55 AM, Fred. Zwarts wrote:

Op 14.feb.2025 om 13:42 schreef olcott:

On 2/14/2025 3:36 AM, joes wrote:

Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:

On 2/13/2025 8:47 AM, Fred. Zwarts wrote:

Op 13.feb.2025 om 13:31 schreef olcott:

On 2/13/2025 3:16 AM, joes wrote:

Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:

On 2/11/2025 2:05 PM, joes wrote:

Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:

On 2/11/2025 9:23 AM, joes wrote:

Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:

On 2/10/2025 2:48 PM, joes wrote:

Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:

On 2/10/2025 6:52 AM, joes wrote:

Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:

On 2/10/2025 5:16 AM, joes wrote:

Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:

On 2/9/2025 1:33 PM, Fred. Zwarts wrote:

Op 09.feb.2025 om 20:04 schreef olcott:

On 2/9/2025 12:54 PM, Fred. Zwarts wrote:

Op 09.feb.2025 om 18:00 schreef olcott:

On 2/9/2025 10:50 AM, Fred. Zwarts wrote:

Op 09.feb.2025 om 16:18 schreef olcott:

On 2/9/2025 2:13 AM, Fred. Zwarts wrote:

Op 09.feb.2025 om 07:10 schreef olcott:

On 2/8/2025 3:54 PM, Fred. Zwarts wrote:

Op 08.feb.2025 om 15:47 schreef olcott:

On 2/8/2025 3:57 AM, Fred. Zwarts wrote:

Op 08.feb.2025 om 06:53 schreef olcott:

On 2/7/2025 7:27 PM, Richard Damon wrote:

On 2/7/25 8:12 PM, olcott wrote:

On 2/7/2025 5:56 PM, Richard Damon wrote:

On 2/7/25 11:26 AM, olcott wrote:

On 2/7/2025 6:20 AM, Richard Damon wrote:

On 2/6/25 10:02 PM, olcott wrote:

>

Which proves that HHH fails to make a correct
decision about DD's halting behaviour. All other
methods (direct execution,
simulation by a world class simulator, etc.) show
that DD halts. But HHH fails to see it. Everyone
with sufficient understanding of programming sees
that HHH is not correctly programmed when it
aborts one cycle before the simulation would end
normally.

The execution trace only shows that HHH is unable
to complete its simulation, because HHH is unable
to simulate itself.

It turns out that Olcott does not even understand
this simple proof that HHH produces false negatives.
HHH is unable to simulate itself up to the normal
termination.

So, in other words, Olcott denies verified facts. HHH
generates false negatives, as is verified in
               int main() {
                 return HHH(main);
               }
but he denies it.
He lacks the ability to accept simple verified facts,
which he tries to hide with a lot of irrelevant words.

It is a verified fact that main cannot possibly be
correctly simulated by HHH until its normal termination.

Indeed, which proves that HHH is unable to simulate
itself correctly.

If this was true then you could point out exactly where
HHH is incorrect.

HHH is supposed to be a decider, i.e. halt and return the
correct value.

The directly executed HHH(DD) always halts and returns a
correct value as soon as it correctly determines that its
input cannot possibly terminate normally.

We were talking about HHH(HHH). If the outer HHH halts
according to spec, so does the inner, because it is the same.
Therefore it can’t report „non-halting” and be correct. If
the inner HHH doesn’t halt, it is not a decider.

I am not going to ever talk about that.

Oh goody, you’re never getting anywhere if you reject corrections.

I reject infinite deflection away from the point. The absolute
single-mined focus point is that DD correctly simulated by HHH
cannot possible terminate normally.

That IS the point. DD does nothing else than call HHH.
>

Since there is a 5% chance that the treatment I will have next month
will kill me and this treatment is my only good chance I will
totally ignore anything that diverges from the point.

Ok, I will wait a month then.
>

Anyone that knows the C language sufficiently well knows that DD
correctly simulated by HHH cannot possibly terminate normally.

>
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because  it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
>

The correct simulation is only the one that it sees by definition. it
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non-input
have always been wrong.

What is the non-input?

>
int main()
{
   DD();    // Is not an input to HHH
   HHH(DD)  // Is an input to HHH
{
>

The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
>

>
>

>
What is the difference in the finite string that describes the first DD and the finite string that describes the second DD?

 The first instance of recursion is not exactly the same as subsequent
instances of the exact same sequence of recursive invocations.

And where did it differ?
Claiming something is not proving it, and being unable to show what you claim is true just demonstrates that you are nothing but a liar.

 It is the same with recursive simulations. When the second recursive
invocation has been aborted the first one terminates normally misleading
people into believing that the recursive chain terminates normally.
 

Except that behavior isn't defined by aborted simulations, and your using that as a basis just shows your ignorance.
The behavior of the program whose simulation was aborted still terminates normally in the full correct simulation or when run, which is what behavior is defined to be.
All you are doing is proving your ignorance, and by refusing to learn, that you are nothing but a fraud.

 

You do not show a definition if DD, but there can be only one DD, so there is only one finite string which can have only one behaviour.
That is the behaviour HHH should decide about. If HHH changes the behaviour of DD, then HHH is not a decider.