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

On 6/1/24 2:11 PM, olcott wrote:

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*
 

No, it doesn't as explained in my other messsage.
You just don't understand what the term means.
Only a simulation of EVERY step of DD until it reaches a final state never reaching there shows that the input does not halt, but HH doesn't do that, and that simulation of any DD based on an HH(DD,DD) that returns 0 will halt.