From Newsgroup: comp.lang.c++

On 10/1/2025 3:49 AM, joes wrote:

Am Mon, 29 Sep 2025 16:39:47 -0500 schrieb olcott:

On 9/29/2025 4:03 PM, joes wrote:

Am Mon, 29 Sep 2025 14:08:15 -0500 schrieb olcott:

On 9/29/2025 1:36 PM, Kaz Kylheku wrote:

HHH correctly determines that Infinite_Loop and Infinite_Loop would
never stop running, no matter how far it simulates them.
It returns 0.
HHH does /not/ correctly determine that DDD would never stop running, >>>>> no matter how far it simulates DDD. That determination is incorrect.

Yes what is a correct non-halting behavior pattern to detect this. I
ask you this because you have seemed to indicate that you just don't
"believe in" non-halting behavior patterns.

There is no pattern to detect this *in every case*. There are
infinitely

I didn't say every case. I said in the two concrete cases provided.

That gets you nowhere. If you think you have one, there is always a counterexample in the shape of DD with your rCRdeciderrCY filled in.

I had to provide those two concrete cases because
Kaz was providing silly head games trying to get
away with saying that Infinite Loops halt.

many patterns applicable to DDD, and all of them fail on another input
in their own specific way. But they all fail.

They succeed in each of my concrete cases.
That you think that they fail is your own lack of comprehension.

They all fail on their respective diagonal input.

*When the halting problem decision*
*problem instance is defined this way*

For decider H and input P
input P halts when H says loops
input P loops when H says halts
making this specific HP decision problem
instance unsatisfiable.

*Not when it is defined this way*

All Turing machine deciders only compute the
mapping from their finite string inputs to an
accept state or reject state on the basis that
this input finite string specifies a semantic
or syntactic property.

A simulating halt decider measures the semantic
halting property specified by its input on the basis
of the behavior of its input simulated by itself.

HHH simulates DD then
this simulated DD calls another instance of HHH(DD)
that causes HHH to simulate an instance of itself
simulating an instance of DD that
calls yet another instance of HHH(DD).

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

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

*or this way*

*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

q0 rf?-nrf- reo* embedded_H rf?-nrf- rf?-nrf- reo* reR // accept state
q0 rf?-nrf- reo* embedded_H rf?-nrf- rf?-nrf- reo* qn // reject state

*Repeats until aborted*
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2