Re: D correctly simulated by H cannot possibly halt --- templates and infinite sets --- deciders

On 6/1/2024 1:07 PM, joes wrote:

Am Thu, 30 May 2024 15:15:32 -0500 schrieb olcott:

On 5/30/2024 2:32 PM, Fred. Zwarts wrote:

Op 30.mei.2024 om 21:01 schreef olcott:

On 5/30/2024 1:50 PM, Fred. Zwarts wrote:

Op 30.mei.2024 om 19:00 schreef olcott:

On 5/30/2024 10:20 AM, Fred. Zwarts wrote:

Op 30.mei.2024 om 16:43 schreef olcott:

On 5/28/2024 11:16 AM, olcott wrote:

>

Because D correctly simulated by H remains stuck in recursive simulation
because D calls H(D,D) in recursive simulation D cannot possibly reach
past its own line 03.
>
You must must 100% complete attention to the exact words that I
exactly say.

Mhm.
 

If you ask to 100% attention, please, pay also attention to the replies
and read more than the first few words. You remove most of my reply,
probably because you did not read them.

I soon as yo show that you are starting with a fundamentally false
assumption I stop reading.

It were helpful if you at least indicated the point where you stopped,
if not dispute the assumption.
 

The fact that D does not reach past line 03, means that lines 04, 05 and
06 do not play a role in the decision.

OK

 

If line 04 cannot be reached, lines 05 and 06 do
not cause any behaviour. In particular no 'pathological' behaviour.

The reason why these lines can't be reached is that D calls H(D,D)
in recursive simulation. This relationship between H and D is
typically called pathological.

If those lines aren't reached, they don't matter and could be removed
or replaced by opposite behaviour.
 

It is H that keeps repeating the simulation of D

D calls H(D,D) in recursive simulation until H stops this.
THIS IS D'S FAULT!
>

and the next H, so the
simulated H never reaches its abort, and therefore it does not reach its
final state. D acts only as a quick parameter duplicator so that H
simulates itself. Then simulated H gets stuck in an infinite recursion
and never reaches the 'pathological' part of D.
Even a beginning C programmer will see that if the simulated H would
really halt (as required),

It does yet you continue to fail to understand this.

If an inner H halts, ...
 

then simulated D would continue to line 04.

No that is utterly impossible because the only reason
that H halts is that it totally stops simulating D.

... then it returns to the outer D that called it.
 

But simulated H does not halt and must be aborted.

 

typedef int (*ptr)();  // ptr is pointer to int function in C
00       int HH(ptr p, ptr i);
01       int DD(ptr p)
02       {
03         int Halt_Status = HH(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         HH(DD,DD);
12         return 0;
13       }
Every DD correctly simulated by any HH that can possibly exist
cannot possibly reach past its own line 03.
A correct simulation means that 1 or more steps of DD are
simulated by pure simulator HH.
*THIS MEANS THAT THE INPUT TO HH(DD,DD) DOES NOT HALT*
*THIS MEANS THAT THE INPUT TO HH(DD,DD) DOES NOT HALT*
*THIS MEANS THAT THE INPUT TO HH(DD,DD) DOES NOT HALT*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer