From Newsgroup: comp.lang.c

On 8/30/2025 1:06 AM, Kaz Kylheku wrote:

On 2025-08-29, olcott <polcott333@gmail.com> wrote:

When I say something 500 times that does not
count as I said it zero times.

DD correctly simulated by HHH specifies the
non-halting behavior pattern of recursive
simulation.

Using a bit of logical formalism:

correctly_simulated(DD) -> ~ halts(DD)

Given P -> Q, we can derive the contrapositive ~Q -> ~P.
In this case:

~ ~ halts(DD) -> ~ correctly_simulated(DD)

Cancel double negative:

halts(DD) -> ~ correctly_simulated(DD)

If HHH can recognize this repeating state as
a pure function of its inputs then HHH(DD)
returns 0 for non-halting and DD() halts.

From this paragraph we can extract:

returns_zero(HHH(DD)) -> halts (DD)

OK, so we have these propositions together:

1. returns_zero(HHH(DD)) -> halts (DD) ;; from second paragraph

2. halts(DD) -> ~ correctly_simulated(DD) ;; from first paragraph

By the transitive property of the arrow: P -> Q ^ Q -> R => P -> R, therefore we have:

3. returns_zero(HHH(DD)) -> ~ correctly_simulated(DD)

You are logically arguing that if HHH(DD) returns
zero, then DD is not correctly simulated (because it halts).

We just use your idea of establishing
naming conventions:

HHH(DD).exe returns 0 because DD.sim1
cannot possibly halt then DD.exe halts.
DD.exe is outside of the scope of HHH.exe.

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

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

DD.exe is executed.
DD.exe calls HHH(DD).exe
HHH.exe simulates DD.sim1
DD.sim1 calls HHH(DD).sim1
HHH.sim1 simulates DD.sim2
DD.sim2 calls HHH(DD).sim2 ... This would repeat unless aborted
if aborted then DD.exe halts

This exact same thing happens with the Linz
Turing Machine based proof.

Machine M contains simulating halt decider H based on a UTM
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.∞
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qn

*Repeats until aborted proving non-halting*
(a) M copies its input ⟨M⟩
(b) M invokes M.H ⟨M⟩ ⟨M⟩
(c) M.H simulates ⟨M⟩ ⟨M⟩

then M.H ⟨M⟩ ⟨M⟩ transitions to M.qn
causing M applied to ⟨M⟩ halt
--
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

From Newsgroup: comp.lang.c

On 2025-08-30 15:08:14 +0000, olcott said:

On 8/30/2025 1:06 AM, Kaz Kylheku wrote:

On 2025-08-29, olcott <polcott333@gmail.com> wrote:

When I say something 500 times that does not
count as I said it zero times.

DD correctly simulated by HHH specifies the
non-halting behavior pattern of recursive
simulation.

Using a bit of logical formalism:

correctly_simulated(DD) -> ~ halts(DD)

Given P -> Q, we can derive the contrapositive ~Q -> ~P.
In this case:

~ ~ halts(DD) -> ~ correctly_simulated(DD)

Cancel double negative:

halts(DD) -> ~ correctly_simulated(DD)

If HHH can recognize this repeating state as
a pure function of its inputs then HHH(DD)
returns 0 for non-halting and DD() halts.

From this paragraph we can extract:

returns_zero(HHH(DD)) -> halts (DD)

OK, so we have these propositions together:

1. returns_zero(HHH(DD)) -> halts (DD) ;; from second paragraph

2. halts(DD) -> ~ correctly_simulated(DD) ;; from first paragraph

By the transitive property of the arrow: P -> Q ^ Q -> R => P -> R,
therefore we have:

3. returns_zero(HHH(DD)) -> ~ correctly_simulated(DD)

You are logically arguing that if HHH(DD) returns
zero, then DD is not correctly simulated (because it halts).

We just use your idea of establishing
naming conventions:

HHH(DD).exe returns 0 because DD.sim1
cannot possibly halt then DD.exe halts.

The code of DD.exe is the same as the code of DD.siml so they specify
the same behaviour. Let N be the number of instructions executed when
DD.exe is executed. It is not possible to simulate correctly nore than
N steps of DD.siml.

DD.exe is outside of the scope of HHH.exe.

Likewise, DD.siml is outside of the scope of the halting problem.
--
Mikko

--- Synchronet 3.21a-Linux NewsLink 1.2