Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:

I have an idea for a signaling simulating halt decider that forks the
simulation into two branches if the input calls the halt decider as
per [Strachey 1965]'s "Impossible Program":

void P(void (*x)())
{ if (H(x, x))
infinite_loop: goto infinite_loop;
return;
}

int main()
{ std::cout << "Input halts: " << H(P, P) << std::endl;
}

When the simulator detects the call to H in P it forks the simulation
into a non-halting branch (returning 0 to P) and a halting branch
(returning 1 to P) and continues the simulation of these two branches
in parallel.

If the non-halting branch is determined to halt AND the halting branch
is determined to not halt then pathology is detected and reported via
a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
sNaN (signaling Not a Number) signal)

If EITHER branch is determined to be correctly decided then that will
be the decision of the halting decider.

Crucially this scheme will handle (and correctly decide) the
following case whereby the result of H is discarded by the input:

void Px(void (*x)())
{ (void) H(x, x);
return;
}

Obviously my idea necessitates extending the definition of a halt
decider:

1) Decider decision is HALTS if input halts.
2) Decider decision is NON-HALTING if input does not halt.
3) Decider rejects pathological input as invalid by signaling sNaP.

https://github.com/i42output/halting-problem#readme

/Flibble

On Monday, October 24, 2022 at 11:19:39 AM UTC-7, Mr Flibble wrote:
> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>
> I have an idea for a signaling simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported via
> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
> sNaN (signaling Not a Number) signal)
>
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.
>
> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> Obviously my idea necessitates extending the definition of a halt
> decider:
>
> 1) Decider decision is HALTS if input halts.
> 2) Decider decision is NON-HALTING if input does not halt.
> 3) Decider rejects pathological input as invalid by signaling sNaP.
>
> https://github.com/i42output/halting-problem#readme
>
> /Flibble

"Simulating" like "spoofing"?

Hello,

I don't know about the Flippledi Fish Application
FFA, which is similar to the Commercial Channel where you can
order a cat toy called "Flibbeldi Fish".

I don't know about SHD, nor I don't know if it a own creation
of a word for private usage (not commonly used abbrev. words).

But, when I read your post's, you would implement a Halt-
problem Application.

Why do you not implement a Thread into your Application, that
check a Timer-Interval-Procedure/Function each 1 ... 4 second
about tasks in the Environment of the Application ?

You can implement a Flag member for Boolean false/true ...
If the flag comes over the Time Limit, then the application is
in idle state, and maybe have a Halt-Problem.

Else, the Flag is false, the Application run in normal mode,
with setting the Timer Inverval to 1.

So far I can see, Microsoft Windows 10/11 start for each single
Task/Application a Reques-Broker this check the main-Application
in the similar way like I describe above.

This implicit, that you have new Hardware, and a huge amount of
Memory.
But in a days, today. This should not be a Problem anymore.

Hope This Helps
Jens

Op 24.okt..2022 om 20:19 schreef Mr Flibble:
> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>
> I have an idea for a signaling simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported via
> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
> sNaN (signaling Not a Number) signal) >
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.

Do you realise that there is fourth case: both branches are determined
to be correctly decided? It happens with a function Po, which does the
opposite of your function P above, it always does what H predicts.
What would your H return in this case?

void Po(void (*x)())
{ if (!H(x, x))
infinite_loop: goto infinite_loop;
return;
}

> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> Obviously my idea necessitates extending the definition of a halt
> decider:
>
> 1) Decider decision is HALTS if input halts.
> 2) Decider decision is NON-HALTING if input does not halt.
> 3) Decider rejects pathological input as invalid by signaling sNaP.
>
> https://github.com/i42output/halting-problem#readme
>
> /Flibble
>

On 10/24/2022 1:19 PM, Mr Flibble wrote:
> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>
> I have an idea for a signaling simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported via
> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
> sNaN (signaling Not a Number) signal)
>
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.
>
> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> Obviously my idea necessitates extending the definition of a halt
> decider:
>
> 1) Decider decision is HALTS if input halts.
> 2) Decider decision is NON-HALTING if input does not halt.
> 3) Decider rejects pathological input as invalid by signaling sNaP.
>
> https://github.com/i42output/halting-problem#readme
>
> /Flibble
>

I created the notion of a simulating halt decider in this forum
On 3/14/2017 at 9:05 AM

Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 09/03/2023 20:31, olcott wrote:
> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>
>> I have an idea for a signaling simulating halt decider that forks the
>> simulation into two branches if the input calls the halt decider as
>> per [Strachey 1965]'s "Impossible Program":
>>
>> void P(void (*x)())
>> {
>>     if (H(x, x))
>>         infinite_loop: goto infinite_loop;
>>     return;
>> }
>>
>> int main()
>> {
>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>> }
>>
>> When the simulator detects the call to H in P it forks the simulation
>> into a non-halting branch (returning 0 to P) and a halting branch
>> (returning 1 to P) and continues the simulation of these two branches
>> in parallel.
>>
>> If the non-halting branch is determined to halt AND the halting branch
>> is determined to not halt then pathology is detected and reported via
>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>> sNaN (signaling Not a Number) signal)
>>
>> If EITHER branch is determined to be correctly decided then that will
>> be the decision of the halting decider.
>>
>> Crucially this scheme will handle (and correctly decide) the
>> following case whereby the result of H is discarded by the input:
>>
>> void Px(void (*x)())
>> {
>>     (void) H(x, x);
>>     return;
>> }
>>
>> Obviously my idea necessitates extending the definition of a halt
>> decider:
>>
>> 1) Decider decision is HALTS if input halts.
>> 2) Decider decision is NON-HALTING if input does not halt.
>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> https://github.com/i42output/halting-problem#readme
>>
>> /Flibble
>>
>
> I created the notion of a simulating halt decider in this forum
> On 3/14/2017 at 9:05 AM
>
> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>

Your simulating halt decider is invalid though as it doesn't distinguish
between non-halting non-pathological input and pathological input. The
Flibble Simulating Halt Decider is the *first* SHD that solves the
halting problem.

/Flibble

On 3/10/2023 6:46 AM, Mr Flibble wrote:
> On 09/03/2023 20:31, olcott wrote:
>> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>>
>>> I have an idea for a signaling simulating halt decider that forks the
>>> simulation into two branches if the input calls the halt decider as
>>> per [Strachey 1965]'s "Impossible Program":
>>>
>>> void P(void (*x)())
>>> {
>>>     if (H(x, x))
>>>         infinite_loop: goto infinite_loop;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>> }
>>>
>>> When the simulator detects the call to H in P it forks the simulation
>>> into a non-halting branch (returning 0 to P) and a halting branch
>>> (returning 1 to P) and continues the simulation of these two branches
>>> in parallel.
>>>
>>> If the non-halting branch is determined to halt AND the halting branch
>>> is determined to not halt then pathology is detected and reported via
>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>> sNaN (signaling Not a Number) signal)
>>>
>>> If EITHER branch is determined to be correctly decided then that will
>>> be the decision of the halting decider.
>>>
>>> Crucially this scheme will handle (and correctly decide) the
>>> following case whereby the result of H is discarded by the input:
>>>
>>> void Px(void (*x)())
>>> {
>>>     (void) H(x, x);
>>>     return;
>>> }
>>>
>>> Obviously my idea necessitates extending the definition of a halt
>>> decider:
>>>
>>> 1) Decider decision is HALTS if input halts.
>>> 2) Decider decision is NON-HALTING if input does not halt.
>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>
>>> https://github.com/i42output/halting-problem#readme
>>>
>>> /Flibble
>>>
>>
>> I created the notion of a simulating halt decider in this forum
>> On 3/14/2017 at 9:05 AM
>>
>> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
>
> Your simulating halt decider is invalid though as it doesn't distinguish
> between non-halting non-pathological input and pathological input.  The
> Flibble Simulating Halt Decider is the *first* SHD that solves the
> halting problem.
>
> /Flibble
>
>

I came up with the idea that the Peter Linz halting problem proof is
decidable as non-halting six years ago in this forum.

On 3/11/2017 3:13 PM [Infinitely Recursive input on HP Proofs]
Message-ID: <918df253-d4f0-4370-8f73-88e6690380a1@googlegroups.com>

All of the conventional halting theorem proofs have this same issue.

Instead of merely detecting the pathological relationship and rejecting
this input, the otherwise "impossible" input is correctly determined to
be non-halting.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 10/03/2023 16:48, olcott wrote:
> On 3/10/2023 6:46 AM, Mr Flibble wrote:
>> On 09/03/2023 20:31, olcott wrote:
>>> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr
>>>> Flibble:
>>>>
>>>> I have an idea for a signaling simulating halt decider that forks the
>>>> simulation into two branches if the input calls the halt decider as
>>>> per [Strachey 1965]'s "Impossible Program":
>>>>
>>>> void P(void (*x)())
>>>> {
>>>>     if (H(x, x))
>>>>         infinite_loop: goto infinite_loop;
>>>>     return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>>> }
>>>>
>>>> When the simulator detects the call to H in P it forks the simulation
>>>> into a non-halting branch (returning 0 to P) and a halting branch
>>>> (returning 1 to P) and continues the simulation of these two branches
>>>> in parallel.
>>>>
>>>> If the non-halting branch is determined to halt AND the halting branch
>>>> is determined to not halt then pathology is detected and reported via
>>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>>> sNaN (signaling Not a Number) signal)
>>>>
>>>> If EITHER branch is determined to be correctly decided then that will
>>>> be the decision of the halting decider.
>>>>
>>>> Crucially this scheme will handle (and correctly decide) the
>>>> following case whereby the result of H is discarded by the input:
>>>>
>>>> void Px(void (*x)())
>>>> {
>>>>     (void) H(x, x);
>>>>     return;
>>>> }
>>>>
>>>> Obviously my idea necessitates extending the definition of a halt
>>>> decider:
>>>>
>>>> 1) Decider decision is HALTS if input halts.
>>>> 2) Decider decision is NON-HALTING if input does not halt.
>>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>>
>>>> https://github.com/i42output/halting-problem#readme
>>>>
>>>> /Flibble
>>>>
>>>
>>> I created the notion of a simulating halt decider in this forum
>>> On 3/14/2017 at 9:05 AM
>>>
>>> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
>>
>> Your simulating halt decider is invalid though as it doesn't
>> distinguish between non-halting non-pathological input and
>> pathological input.  The Flibble Simulating Halt Decider is the
>> *first* SHD that solves the halting problem.
>>
>> /Flibble
>>
>>
>
> I came up with the idea that the Peter Linz halting problem proof is
> decidable as non-halting six years ago in this forum.
>
> On 3/11/2017 3:13 PM  [Infinitely Recursive input on HP Proofs]
> Message-ID: <918df253-d4f0-4370-8f73-88e6690380a1@googlegroups.com>
>
> All of the conventional halting theorem proofs have this same issue.
>
> Instead of merely detecting the pathological relationship and rejecting
> this input, the otherwise "impossible" input is correctly determined to
> be non-halting.

A halt decider MUST give a ternary result that includes "invalid input";
the traditional binary result of halting/non-halting is not sufficient
to solve the halting problem as it doesn't recognize the category error
present in the definition of the problem. Your SHD is invalid and
worthless; Mr Flibble SHD is perfect and correct.

/Flibble

On 3/10/2023 1:05 PM, Mr Flibble wrote:
> On 10/03/2023 16:48, olcott wrote:
>> On 3/10/2023 6:46 AM, Mr Flibble wrote:
>>> On 09/03/2023 20:31, olcott wrote:
>>>> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>>>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr
>>>>> Flibble:
>>>>>
>>>>> I have an idea for a signaling simulating halt decider that forks the
>>>>> simulation into two branches if the input calls the halt decider as
>>>>> per [Strachey 1965]'s "Impossible Program":
>>>>>
>>>>> void P(void (*x)())
>>>>> {
>>>>>     if (H(x, x))
>>>>>         infinite_loop: goto infinite_loop;
>>>>>     return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>>>> }
>>>>>
>>>>> When the simulator detects the call to H in P it forks the simulation
>>>>> into a non-halting branch (returning 0 to P) and a halting branch
>>>>> (returning 1 to P) and continues the simulation of these two branches
>>>>> in parallel.
>>>>>
>>>>> If the non-halting branch is determined to halt AND the halting branch
>>>>> is determined to not halt then pathology is detected and reported via
>>>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>>>> sNaN (signaling Not a Number) signal)
>>>>>
>>>>> If EITHER branch is determined to be correctly decided then that will
>>>>> be the decision of the halting decider.
>>>>>
>>>>> Crucially this scheme will handle (and correctly decide) the
>>>>> following case whereby the result of H is discarded by the input:
>>>>>
>>>>> void Px(void (*x)())
>>>>> {
>>>>>     (void) H(x, x);
>>>>>     return;
>>>>> }
>>>>>
>>>>> Obviously my idea necessitates extending the definition of a halt
>>>>> decider:
>>>>>
>>>>> 1) Decider decision is HALTS if input halts.
>>>>> 2) Decider decision is NON-HALTING if input does not halt.
>>>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>>>
>>>>> https://github.com/i42output/halting-problem#readme
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> I created the notion of a simulating halt decider in this forum
>>>> On 3/14/2017 at 9:05 AM
>>>>
>>>> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
>>>
>>> Your simulating halt decider is invalid though as it doesn't
>>> distinguish between non-halting non-pathological input and
>>> pathological input.  The Flibble Simulating Halt Decider is the
>>> *first* SHD that solves the halting problem.
>>>
>>> /Flibble
>>>
>>>
>>
>> I came up with the idea that the Peter Linz halting problem proof is
>> decidable as non-halting six years ago in this forum.
>>
>> On 3/11/2017 3:13 PM  [Infinitely Recursive input on HP Proofs]
>> Message-ID: <918df253-d4f0-4370-8f73-88e6690380a1@googlegroups.com>
>>
>> All of the conventional halting theorem proofs have this same issue.
>>
>> Instead of merely detecting the pathological relationship and rejecting
>> this input, the otherwise "impossible" input is correctly determined to
>> be non-halting.
>
> A halt decider MUST give a ternary result that includes "invalid input";
> the traditional binary result of halting/non-halting is not sufficient
> to solve the halting problem as it doesn't recognize the category error
> present in the definition of the problem.  Your SHD is invalid and
> worthless; Mr Flibble SHD is perfect and correct.
>
> /Flibble
>
>

You can't even provide the criterion measure that you use in the
conditional statements that recognizes pathological self-reference
(Olcott 2004).

01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

I provide fully operational software that does correctly determine that
D correctly simulated by H cannot possibly reach its own "return"
instruction and halt whether or not this simulation is ever aborted.

H(D,D) is fully operational in the x86utm operating system:
https://github.com/plolcott/x86utm

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 10/03/2023 19:29, olcott wrote:
> On 3/10/2023 1:05 PM, Mr Flibble wrote:
>> On 10/03/2023 16:48, olcott wrote:
>>> On 3/10/2023 6:46 AM, Mr Flibble wrote:
>>>> On 09/03/2023 20:31, olcott wrote:
>>>>> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>>>>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr
>>>>>> Flibble:
>>>>>>
>>>>>> I have an idea for a signaling simulating halt decider that forks the
>>>>>> simulation into two branches if the input calls the halt decider as
>>>>>> per [Strachey 1965]'s "Impossible Program":
>>>>>>
>>>>>> void P(void (*x)())
>>>>>> {
>>>>>>     if (H(x, x))
>>>>>>         infinite_loop: goto infinite_loop;
>>>>>>     return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>>>>> }
>>>>>>
>>>>>> When the simulator detects the call to H in P it forks the simulation
>>>>>> into a non-halting branch (returning 0 to P) and a halting branch
>>>>>> (returning 1 to P) and continues the simulation of these two branches
>>>>>> in parallel.
>>>>>>
>>>>>> If the non-halting branch is determined to halt AND the halting
>>>>>> branch
>>>>>> is determined to not halt then pathology is detected and reported via
>>>>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>>>>> sNaN (signaling Not a Number) signal)
>>>>>>
>>>>>> If EITHER branch is determined to be correctly decided then that will
>>>>>> be the decision of the halting decider.
>>>>>>
>>>>>> Crucially this scheme will handle (and correctly decide) the
>>>>>> following case whereby the result of H is discarded by the input:
>>>>>>
>>>>>> void Px(void (*x)())
>>>>>> {
>>>>>>     (void) H(x, x);
>>>>>>     return;
>>>>>> }
>>>>>>
>>>>>> Obviously my idea necessitates extending the definition of a halt
>>>>>> decider:
>>>>>>
>>>>>> 1) Decider decision is HALTS if input halts.
>>>>>> 2) Decider decision is NON-HALTING if input does not halt.
>>>>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>>>>
>>>>>> https://github.com/i42output/halting-problem#readme
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> I created the notion of a simulating halt decider in this forum
>>>>> On 3/14/2017 at 9:05 AM
>>>>>
>>>>> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
>>>>
>>>> Your simulating halt decider is invalid though as it doesn't
>>>> distinguish between non-halting non-pathological input and
>>>> pathological input.  The Flibble Simulating Halt Decider is the
>>>> *first* SHD that solves the halting problem.
>>>>
>>>> /Flibble
>>>>
>>>>
>>>
>>> I came up with the idea that the Peter Linz halting problem proof is
>>> decidable as non-halting six years ago in this forum.
>>>
>>> On 3/11/2017 3:13 PM  [Infinitely Recursive input on HP Proofs]
>>> Message-ID: <918df253-d4f0-4370-8f73-88e6690380a1@googlegroups.com>
>>>
>>> All of the conventional halting theorem proofs have this same issue.
>>>
>>> Instead of merely detecting the pathological relationship and rejecting
>>> this input, the otherwise "impossible" input is correctly determined to
>>> be non-halting.
>>
>> A halt decider MUST give a ternary result that includes "invalid
>> input"; the traditional binary result of halting/non-halting is not
>> sufficient to solve the halting problem as it doesn't recognize the
>> category error present in the definition of the problem.  Your SHD is
>> invalid and worthless; Mr Flibble SHD is perfect and correct.
>>
>> /Flibble
>>
>>
>
> You can't even provide the criterion measure that you use in the
> conditional statements that recognizes pathological self-reference
> (Olcott 2004).
>
> 01 int D(int (*x)())
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> I provide fully operational software that does correctly determine that
> D correctly simulated by H cannot possibly reach its own "return"
> instruction and halt whether or not this simulation is ever aborted.
>
> H(D,D) is fully operational in the x86utm operating system:
> https://github.com/plolcott/x86utm

Software that is fully operational and wrong is still wrong, and
worthless. A SHD *must* return a ternary result that includes "invalid
program" in order to solve the halting problem as the SHD *must*
correctly recognize the category error present in the definition of the
problem itself.

/Flibble

On 3/10/2023 1:41 PM, Mr Flibble wrote:
> On 10/03/2023 19:29, olcott wrote:
>> On 3/10/2023 1:05 PM, Mr Flibble wrote:
>>> On 10/03/2023 16:48, olcott wrote:
>>>> On 3/10/2023 6:46 AM, Mr Flibble wrote:
>>>>> On 09/03/2023 20:31, olcott wrote:
>>>>>> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>>>>>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr
>>>>>>> Flibble:
>>>>>>>
>>>>>>> I have an idea for a signaling simulating halt decider that forks
>>>>>>> the
>>>>>>> simulation into two branches if the input calls the halt decider as
>>>>>>> per [Strachey 1965]'s "Impossible Program":
>>>>>>>
>>>>>>> void P(void (*x)())
>>>>>>> {
>>>>>>>     if (H(x, x))
>>>>>>>         infinite_loop: goto infinite_loop;
>>>>>>>     return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>>>>>> }
>>>>>>>
>>>>>>> When the simulator detects the call to H in P it forks the
>>>>>>> simulation
>>>>>>> into a non-halting branch (returning 0 to P) and a halting branch
>>>>>>> (returning 1 to P) and continues the simulation of these two
>>>>>>> branches
>>>>>>> in parallel.
>>>>>>>
>>>>>>> If the non-halting branch is determined to halt AND the halting
>>>>>>> branch
>>>>>>> is determined to not halt then pathology is detected and reported
>>>>>>> via
>>>>>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>>>>>> sNaN (signaling Not a Number) signal)
>>>>>>>
>>>>>>> If EITHER branch is determined to be correctly decided then that
>>>>>>> will
>>>>>>> be the decision of the halting decider.
>>>>>>>
>>>>>>> Crucially this scheme will handle (and correctly decide) the
>>>>>>> following case whereby the result of H is discarded by the input:
>>>>>>>
>>>>>>> void Px(void (*x)())
>>>>>>> {
>>>>>>>     (void) H(x, x);
>>>>>>>     return;
>>>>>>> }
>>>>>>>
>>>>>>> Obviously my idea necessitates extending the definition of a halt
>>>>>>> decider:
>>>>>>>
>>>>>>> 1) Decider decision is HALTS if input halts.
>>>>>>> 2) Decider decision is NON-HALTING if input does not halt.
>>>>>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>>>>>
>>>>>>> https://github.com/i42output/halting-problem#readme
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> I created the notion of a simulating halt decider in this forum
>>>>>> On 3/14/2017 at 9:05 AM
>>>>>>
>>>>>> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
>>>>>
>>>>> Your simulating halt decider is invalid though as it doesn't
>>>>> distinguish between non-halting non-pathological input and
>>>>> pathological input.  The Flibble Simulating Halt Decider is the
>>>>> *first* SHD that solves the halting problem.
>>>>>
>>>>> /Flibble
>>>>>
>>>>>
>>>>
>>>> I came up with the idea that the Peter Linz halting problem proof is
>>>> decidable as non-halting six years ago in this forum.
>>>>
>>>> On 3/11/2017 3:13 PM  [Infinitely Recursive input on HP Proofs]
>>>> Message-ID: <918df253-d4f0-4370-8f73-88e6690380a1@googlegroups.com>
>>>>
>>>> All of the conventional halting theorem proofs have this same issue.
>>>>
>>>> Instead of merely detecting the pathological relationship and rejecting
>>>> this input, the otherwise "impossible" input is correctly determined to
>>>> be non-halting.
>>>
>>> A halt decider MUST give a ternary result that includes "invalid
>>> input"; the traditional binary result of halting/non-halting is not
>>> sufficient to solve the halting problem as it doesn't recognize the
>>> category error present in the definition of the problem.  Your SHD is
>>> invalid and worthless; Mr Flibble SHD is perfect and correct.
>>>
>>> /Flibble
>>>
>>>
>>
>> You can't even provide the criterion measure that you use in the
>> conditional statements that recognizes pathological self-reference
>> (Olcott 2004).
>>
>> 01 int D(int (*x)())
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> I provide fully operational software that does correctly determine that
>> D correctly simulated by H cannot possibly reach its own "return"
>> instruction and halt whether or not this simulation is ever aborted.
>>
>> H(D,D) is fully operational in the x86utm operating system:
>> https://github.com/plolcott/x86utm
>
> Software that is fully operational and wrong is still wrong, and
> worthless.  A SHD *must* return a ternary result that includes "invalid
> program" in order to solve the halting problem as the SHD *must*
> correctly recognize the category error present in the definition of the
> problem itself.
>
> /Flibble
>

Ordinary software engineering conclusively proves that D correctly
simulated by H cannot possibly reach its own simulated return
instruction and halt.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 10/24/2022 1:19 PM, Mr Flibble wrote:
> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>
> I have an idea for a signaling simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported via
> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
> sNaN (signaling Not a Number) signal)
>
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.
>
> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> Obviously my idea necessitates extending the definition of a halt
> decider:
>
> 1) Decider decision is HALTS if input halts.
> 2) Decider decision is NON-HALTING if input does not halt.
> 3) Decider rejects pathological input as invalid by signaling sNaP.
>
> https://github.com/i42output/halting-problem#readme
>
> /Flibble
>

The Halting Paradox
Bill Stoddart
20 December 2017
https://arxiv.org/pdf/1906.05340.pdf

Our programming intuition tells us that S will not terminate because
when H (S) is invoked within S, H will not terminate. However, we cannot
require H to return a value to report this, because that would require
it to terminate! We provide a programming example based on a a halt test
for a small set of programs, where we resolve this by allowing the
option for the halt test to report via an error message when it finds
itself in this situation. However, we can require that the halt test
should always halt in other situations.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/14/23 2:51 PM, olcott wrote:
> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>
>> I have an idea for a signaling simulating halt decider that forks the
>> simulation into two branches if the input calls the halt decider as
>> per [Strachey 1965]'s "Impossible Program":
>>
>> void P(void (*x)())
>> {
>>     if (H(x, x))
>>         infinite_loop: goto infinite_loop;
>>     return;
>> }
>>
>> int main()
>> {
>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>> }
>>
>> When the simulator detects the call to H in P it forks the simulation
>> into a non-halting branch (returning 0 to P) and a halting branch
>> (returning 1 to P) and continues the simulation of these two branches
>> in parallel.
>>
>> If the non-halting branch is determined to halt AND the halting branch
>> is determined to not halt then pathology is detected and reported via
>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>> sNaN (signaling Not a Number) signal)
>>
>> If EITHER branch is determined to be correctly decided then that will
>> be the decision of the halting decider.
>>
>> Crucially this scheme will handle (and correctly decide) the
>> following case whereby the result of H is discarded by the input:
>>
>> void Px(void (*x)())
>> {
>>     (void) H(x, x);
>>     return;
>> }
>>
>> Obviously my idea necessitates extending the definition of a halt
>> decider:
>>
>> 1) Decider decision is HALTS if input halts.
>> 2) Decider decision is NON-HALTING if input does not halt.
>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> https://github.com/i42output/halting-problem#readme
>>
>> /Flibble
>>
>
>
> The Halting Paradox
> Bill Stoddart
> 20 December 2017
> https://arxiv.org/pdf/1906.05340.pdf
>
> Our programming intuition tells us that S will not terminate because
> when H (S) is invoked within S, H will not terminate. However, we cannot
> require H to return a value to report this, because that would require
> it to terminate! We provide a programming example based on a a halt test
> for a small set of programs, where we resolve this by allowing the
> option for the halt test to report via an error message when it finds
> itself in this situation. However, we can require that the halt test
> should always halt in other situations.
>
>

So, you don't notice that he actually ACCEPTS that the Halting Problem,
AS DEFINED, is in fact, impossible to solve, but tries to see if there
is some way to alter the "rules" of computability theory to allow one to
define one.

Yes, if a program can use data that isn't part of its formal input, it
might be able to do something, but then compuations are no longer
representives of mathematical mappings, so such a definition breaks the
usefulness of the Theory.

On 3/14/2023 1:51 PM, olcott wrote:
> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>
>> I have an idea for a signaling simulating halt decider that forks the
>> simulation into two branches if the input calls the halt decider as
>> per [Strachey 1965]'s "Impossible Program":
>>
>> void P(void (*x)())
>> {
>>     if (H(x, x))
>>         infinite_loop: goto infinite_loop;
>>     return;
>> }
>>
>> int main()
>> {
>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>> }
>>
>> When the simulator detects the call to H in P it forks the simulation
>> into a non-halting branch (returning 0 to P) and a halting branch
>> (returning 1 to P) and continues the simulation of these two branches
>> in parallel.
>>
>> If the non-halting branch is determined to halt AND the halting branch
>> is determined to not halt then pathology is detected and reported via
>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>> sNaN (signaling Not a Number) signal)
>>
>> If EITHER branch is determined to be correctly decided then that will
>> be the decision of the halting decider.
>>
>> Crucially this scheme will handle (and correctly decide) the
>> following case whereby the result of H is discarded by the input:
>>
>> void Px(void (*x)())
>> {
>>     (void) H(x, x);
>>     return;
>> }
>>
>> Obviously my idea necessitates extending the definition of a halt
>> decider:
>>
>> 1) Decider decision is HALTS if input halts.
>> 2) Decider decision is NON-HALTING if input does not halt.
>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> https://github.com/i42output/halting-problem#readme
>>
>> /Flibble
>>
>
>
> The Halting Paradox
> Bill Stoddart
> 20 December 2017
> https://arxiv.org/pdf/1906.05340.pdf
>
> Our programming intuition tells us that S will not terminate because
> when H (S) is invoked within S, H will not terminate. However, we cannot
> require H to return a value to report this, because that would require
> it to terminate! We provide a programming example based on a a halt test
> for a small set of programs, where we resolve this by allowing the
> option for the halt test to report via an error message when it finds
> itself in this situation. However, we can require that the halt test
> should always halt in other situations.
>
>

Olcott simulating halt decider exactly six years ago today
Newsgroups: comp.theory
Date: Tue, 14 Mar 2017 07:05:35 -0700 (PDT)
Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
Subject: Solution to one instance of the Halting Problem

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 10/24/2022 11:19 AM, Mr Flibble wrote:
> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>
> I have an idea for a signaling simulating halt decider that forks the
> simulation into two branches if the input calls the halt decider as
> per [Strachey 1965]'s "Impossible Program":
>
> void P(void (*x)())
> {
> if (H(x, x))
> infinite_loop: goto infinite_loop;
> return;
> }
>
> int main()
> {
> std::cout << "Input halts: " << H(P, P) << std::endl;
> }
>
> When the simulator detects the call to H in P it forks the simulation
> into a non-halting branch (returning 0 to P) and a halting branch
> (returning 1 to P) and continues the simulation of these two branches
> in parallel.
>
> If the non-halting branch is determined to halt AND the halting branch
> is determined to not halt then pathology is detected and reported via
> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
> sNaN (signaling Not a Number) signal)
>
> If EITHER branch is determined to be correctly decided then that will
> be the decision of the halting decider.
>
> Crucially this scheme will handle (and correctly decide) the
> following case whereby the result of H is discarded by the input:
>
> void Px(void (*x)())
> {
> (void) H(x, x);
> return;
> }
>
> Obviously my idea necessitates extending the definition of a halt
> decider:
>
> 1) Decider decision is HALTS if input halts.
> 2) Decider decision is NON-HALTING if input does not halt.
> 3) Decider rejects pathological input as invalid by signaling sNaP.

Can it handle a so-called "black box" program? Does it halt?

On 3/14/2023 8:13 PM, Chris M. Thomasson wrote:
> On 10/24/2022 11:19 AM, Mr Flibble wrote:
>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>
>> I have an idea for a signaling simulating halt decider that forks the
>> simulation into two branches if the input calls the halt decider as
>> per [Strachey 1965]'s "Impossible Program":
>>
>> void P(void (*x)())
>> {
>>     if (H(x, x))
>>         infinite_loop: goto infinite_loop;
>>     return;
>> }
>>
>> int main()
>> {
>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>> }
>>
>> When the simulator detects the call to H in P it forks the simulation
>> into a non-halting branch (returning 0 to P) and a halting branch
>> (returning 1 to P) and continues the simulation of these two branches
>> in parallel.
>>
>> If the non-halting branch is determined to halt AND the halting branch
>> is determined to not halt then pathology is detected and reported via
>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>> sNaN (signaling Not a Number) signal)
>>
>> If EITHER branch is determined to be correctly decided then that will
>> be the decision of the halting decider.
>>
>> Crucially this scheme will handle (and correctly decide) the
>> following case whereby the result of H is discarded by the input:
>>
>> void Px(void (*x)())
>> {
>>     (void) H(x, x);
>>     return;
>> }
>>
>> Obviously my idea necessitates extending the definition of a halt
>> decider:
>>
>> 1) Decider decision is HALTS if input halts.
>> 2) Decider decision is NON-HALTING if input does not halt.
>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>
> Can it handle a so-called "black box" program? Does it halt?
>
>

This is not Flibble's idea, This is my idea.
Flibble says that he is only a troll and does not mean what he says.

01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

If you want to talk about this more meet me on comp.theory.
My halt decider is fully operational code.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/14/23 10:08 PM, olcott wrote:
> On 3/14/2023 8:13 PM, Chris M. Thomasson wrote:
>> On 10/24/2022 11:19 AM, Mr Flibble wrote:
>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>>
>>> I have an idea for a signaling simulating halt decider that forks the
>>> simulation into two branches if the input calls the halt decider as
>>> per [Strachey 1965]'s "Impossible Program":
>>>
>>> void P(void (*x)())
>>> {
>>>     if (H(x, x))
>>>         infinite_loop: goto infinite_loop;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>> }
>>>
>>> When the simulator detects the call to H in P it forks the simulation
>>> into a non-halting branch (returning 0 to P) and a halting branch
>>> (returning 1 to P) and continues the simulation of these two branches
>>> in parallel.
>>>
>>> If the non-halting branch is determined to halt AND the halting branch
>>> is determined to not halt then pathology is detected and reported via
>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>> sNaN (signaling Not a Number) signal)
>>>
>>> If EITHER branch is determined to be correctly decided then that will
>>> be the decision of the halting decider.
>>>
>>> Crucially this scheme will handle (and correctly decide) the
>>> following case whereby the result of H is discarded by the input:
>>>
>>> void Px(void (*x)())
>>> {
>>>     (void) H(x, x);
>>>     return;
>>> }
>>>
>>> Obviously my idea necessitates extending the definition of a halt
>>> decider:
>>>
>>> 1) Decider decision is HALTS if input halts.
>>> 2) Decider decision is NON-HALTING if input does not halt.
>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> Can it handle a so-called "black box" program? Does it halt?
>>
>>
>
> This is not Flibble's idea, This is my idea.
> Flibble says that he is only a troll and does not mean what he says.
>
> 01 int D(int (*x)())
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> If you want to talk about this more meet me on comp.theory.
> My halt decider is fully operational code.
>

Except that it says that D(D) will not halt, when it does, because H
thinks that the H(D,D) called by D won't return, thus it gives the wrong
answer.

At least Flibble's code admits it found something it couldn't answer,
and gives a third answer, which while not exactly correct, also isn't
the incorrect answer that yours gives.

On 3/14/2023 9:08 PM, olcott wrote:
> On 3/14/2023 8:13 PM, Chris M. Thomasson wrote:
>> On 10/24/2022 11:19 AM, Mr Flibble wrote:
>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>>
>>> I have an idea for a signaling simulating halt decider that forks the
>>> simulation into two branches if the input calls the halt decider as
>>> per [Strachey 1965]'s "Impossible Program":
>>>
>>> void P(void (*x)())
>>> {
>>>     if (H(x, x))
>>>         infinite_loop: goto infinite_loop;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>> }
>>>
>>> When the simulator detects the call to H in P it forks the simulation
>>> into a non-halting branch (returning 0 to P) and a halting branch
>>> (returning 1 to P) and continues the simulation of these two branches
>>> in parallel.
>>>
>>> If the non-halting branch is determined to halt AND the halting branch
>>> is determined to not halt then pathology is detected and reported via
>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>> sNaN (signaling Not a Number) signal)
>>>
>>> If EITHER branch is determined to be correctly decided then that will
>>> be the decision of the halting decider.
>>>
>>> Crucially this scheme will handle (and correctly decide) the
>>> following case whereby the result of H is discarded by the input:
>>>
>>> void Px(void (*x)())
>>> {
>>>     (void) H(x, x);
>>>     return;
>>> }
>>>
>>> Obviously my idea necessitates extending the definition of a halt
>>> decider:
>>>
>>> 1) Decider decision is HALTS if input halts.
>>> 2) Decider decision is NON-HALTING if input does not halt.
>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> Can it handle a so-called "black box" program? Does it halt?
>>
>>
>
> This is not Flibble's idea, This is my idea.
> Flibble says that he is only a troll and does not mean what he says.
>
> 01 int D(int (*x)())
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> If you want to talk about this more meet me on comp.theory.
> My halt decider is fully operational code.

Flibble does not have nearly as much as a single encoded "if" statement
to detect what he is looking for because he does not even have any
criteria for encoding this "if" statement

His idea of "category error" was his only brilliant insight.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

In article <tur9bh$jo9p$1@dont-email.me>,
olcott <polcott2@gmail.com> wrote:

> If you want to talk about this more meet me on comp.theory.
> My halt decider is fully operational code.

So if my program continues until it finds an exception to
goldbach's conjecture, your fully operational code will tell me
if it halts?

--
:-<> Siri Seal of Disavowal #000-001. Disavowed. Denied. Deleted. @
'I desire mercy, not sacrifice.' /|\
Discordia: not just a religion but also a parody. This post / \
I am an Andrea Chen sockpuppet. insults Islam. Mohammed

On 3/14/2023 11:11 PM, Siri Cruise wrote:
> In article <tur9bh$jo9p$1@dont-email.me>,
> olcott <polcott2@gmail.com> wrote:
>
>> If you want to talk about this more meet me on comp.theory.
>> My halt decider is fully operational code.
>
> So if my program continues until it finds an exception to
> goldbach's conjecture, your fully operational code will tell me
> if it halts?
>

01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

I only correctly determine the halt status of the above "impossible"
input that previously proved the halting theorem.
--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/14/2023 2:51 PM, olcott wrote:

<snip>

> --
> Copyright 2023 Olcott "Talent hits a target no one else can hit;
> Genius hits a target no one else can see." Arthur Schopenhauer

To everyone: this filthy scumbag "Peter Olcott" was arrested in Apr 2015
for possession of copious amounts of child pornography.

"Investigators reportedly seized 30 VHS tapes of suspected child
pornography and more than 100 magazines and pictures of child pornography."

https://www.ketv.com/article/man-believed-child-porn-was-legal-because-he-was-god-authorities-say/7652218

Also:
https://www.youtube.com/watch?v=wfPPJBYc2B0

On 3/14/2023 1:51 PM, olcott wrote:
> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>
>> I have an idea for a signaling simulating halt decider that forks the
>> simulation into two branches if the input calls the halt decider as
>> per [Strachey 1965]'s "Impossible Program":
>>
>> void P(void (*x)())
>> {
>>     if (H(x, x))
>>         infinite_loop: goto infinite_loop;
>>     return;
>> }
>>
>> int main()
>> {
>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>> }
>>
>> When the simulator detects the call to H in P it forks the simulation
>> into a non-halting branch (returning 0 to P) and a halting branch
>> (returning 1 to P) and continues the simulation of these two branches
>> in parallel.
>>
>> If the non-halting branch is determined to halt AND the halting branch
>> is determined to not halt then pathology is detected and reported via
>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>> sNaN (signaling Not a Number) signal)
>>
>> If EITHER branch is determined to be correctly decided then that will
>> be the decision of the halting decider.
>>
>> Crucially this scheme will handle (and correctly decide) the
>> following case whereby the result of H is discarded by the input:
>>
>> void Px(void (*x)())
>> {
>>     (void) H(x, x);
>>     return;
>> }
>>
>> Obviously my idea necessitates extending the definition of a halt
>> decider:
>>
>> 1) Decider decision is HALTS if input halts.
>> 2) Decider decision is NON-HALTING if input does not halt.
>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>
>> https://github.com/i42output/halting-problem#readme
>>
>> /Flibble
>>
>
>
> The Halting Paradox
> Bill Stoddart
> 20 December 2017
> https://arxiv.org/pdf/1906.05340.pdf
>
> Our programming intuition tells us that S will not terminate because
> when H (S) is invoked within S, H will not terminate. However, we cannot
> require H to return a value to report this, because that would require
> it to terminate! We provide a programming example based on a a halt test
> for a small set of programs, where we resolve this by allowing the
> option for the halt test to report via an error message when it finds
> itself in this situation. However, we can require that the halt test
> should always halt in other situations.
>
>

I am protecting the ownership of my work.
I have 15,000 hours invested since 2004.

Flibble's claim of having a copyright on a signalling simulating halt
decider is bogus. The above reference for a signalling halt decider
predates Flibble's claim.

This message ID proves that I originated the concept of a simulating
halt decider applied to the halting theorem's "impossible" input.

Newsgroups: comp.theory
Date: Tue, 14 Mar 2017 07:05:35 -0700 (PDT)
Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
Subject: Solution to one instance of the Halting Problem

01 int D(int (*x)())
02 {
03 int Halt_Status = H(x, x);
04 if (Halt_Status)
05 HERE: goto HERE;
06 return Halt_Status;
07 }
08
09 void main()
10 {
11 H(D,D);
12 }

I really have defeated the halting problem proofs in that I have fully
operational code that does correctly determine the halt status of the
halting problem's "impossible" input. This work has great impact in that
it corrects an key error at the foundation of computer science.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/15/23 12:04 PM, olcott wrote:
> On 3/14/2023 1:51 PM, olcott wrote:
>> On 10/24/2022 1:19 PM, Mr Flibble wrote:
>>> Signaling (Simulating) Halt Decider (SHD) Copyright (c) 2022 Mr Flibble:
>>>
>>> I have an idea for a signaling simulating halt decider that forks the
>>> simulation into two branches if the input calls the halt decider as
>>> per [Strachey 1965]'s "Impossible Program":
>>>
>>> void P(void (*x)())
>>> {
>>>     if (H(x, x))
>>>         infinite_loop: goto infinite_loop;
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     std::cout << "Input halts: " << H(P, P) << std::endl;
>>> }
>>>
>>> When the simulator detects the call to H in P it forks the simulation
>>> into a non-halting branch (returning 0 to P) and a halting branch
>>> (returning 1 to P) and continues the simulation of these two branches
>>> in parallel.
>>>
>>> If the non-halting branch is determined to halt AND the halting branch
>>> is determined to not halt then pathology is detected and reported via
>>> a sNaP (signaling Not a Program) signal (analogous to IEEE 754's
>>> sNaN (signaling Not a Number) signal)
>>>
>>> If EITHER branch is determined to be correctly decided then that will
>>> be the decision of the halting decider.
>>>
>>> Crucially this scheme will handle (and correctly decide) the
>>> following case whereby the result of H is discarded by the input:
>>>
>>> void Px(void (*x)())
>>> {
>>>     (void) H(x, x);
>>>     return;
>>> }
>>>
>>> Obviously my idea necessitates extending the definition of a halt
>>> decider:
>>>
>>> 1) Decider decision is HALTS if input halts.
>>> 2) Decider decision is NON-HALTING if input does not halt.
>>> 3) Decider rejects pathological input as invalid by signaling sNaP.
>>>
>>> https://github.com/i42output/halting-problem#readme
>>>
>>> /Flibble
>>>
>>
>>
>> The Halting Paradox
>> Bill Stoddart
>> 20 December 2017
>> https://arxiv.org/pdf/1906.05340.pdf
>>
>> Our programming intuition tells us that S will not terminate because
>> when H (S) is invoked within S, H will not terminate. However, we
>> cannot require H to return a value to report this, because that would
>> require it to terminate! We provide a programming example based on a a
>> halt test for a small set of programs, where we resolve this by
>> allowing the option for the halt test to report via an error message
>> when it finds itself in this situation. However, we can require that
>> the halt test should always halt in other situations.
>>
>>
>
> I am protecting the ownership of my work.
> I have 15,000 hours invested since 2004.
>
> Flibble's claim of having a copyright on a signalling simulating halt
> decider is bogus. The above reference for a signalling halt decider
> predates Flibble's claim.

Except I have heard you claim that idea of a SIGNALLING Halt Decider,
that is a decider that gave a DIFFERENT output on the "pathological" case.

You have always (as far as I know) tried to claim that for this input
"Non-Halting" is correct, even though the input when run halts, so that
answer is BY DEFINITION incorrect.

>
> This message ID proves that I originated the concept of a simulating
> halt decider applied to the halting theorem's "impossible" input.
>
> Newsgroups: comp.theory
> Date: Tue, 14 Mar 2017 07:05:35 -0700 (PDT)
> Message-ID: <e18ff0a9-7f9d-4799-9d13-55d021afaa82@googlegroups.com>
> Subject: Solution to one instance of the Halting Problem
>
> 01 int D(int (*x)())
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> I really have defeated the halting problem proofs in that I have fully
> operational code that does correctly determine the halt status of the
> halting problem's "impossible" input. This work has great impact in that
> it corrects an key error at the foundation of computer science.
>

But Your H answers Non-Halting when D(D) Halts, so that can not be the
correct answer.

At least Flibble's machine admits that it can't give the technically
correct answer and gives something else, so while not the actual "Right"
answer, it isn't the clearly Wrong answer.