# Re: olcott is absolutely correct. [ Visual Studio c/c++ project ]

4 views

### olcott

Oct 1, 2022, 11:09:21 AMOct 1
to
On 10/1/2022 9:48 AM, Mr Flibble wrote:
> On Sat, 1 Oct 2022 17:23:18 +0300
> Mikko <mikko....@iki.fi> wrote:
>
>> On 2022-10-01 12:43:34 +0000, Mr Flibble said:
>>
>>> On Sat, 1 Oct 2022 14:54:03 +0300
>>> Mikko <mikko....@iki.fi> wrote:
>>>
>>>> On 2022-09-29 17:48:14 +0000, Mr Flibble said:
>>>>
>>>>> On Thu, 29 Sep 2022 10:37:46 -0700
>>>>> Keith Thompson <Keith.S.T...@gmail.com> wrote:
>>>>
>>>>>> Yes, if a simulating halt decider existed, it would refute the
>>>>>> halting problem proofs.
>>>>
>>>>> It does exist: it is called the Flibble Signaling Decider (tm). I
>>>>> have refuted the halting problem proofs.
>>>>
>>>> The Flibble Signaling Decider is not a halt decider and therefore
>>>> does not refute the halting problem proofs.
>>>
>>> The Flibble Signaling Decider is a halt decider and therefore does
>>> refute the halting problem proofs.
>>>
>>> /Flibble
>>
>> No, it isn't. A halt decider says either "yes" or "no" for every
>> input. For some inputs your "decider" says neither, so it is not a
>> halt decider.
>
> The Flibble Signaling Decider does say "yes" or "no" for
> non-pathological inputs and signals an exception for pathological
> inputs, so it is a halt decider and therefore does refute the halting
> problem proofs.
>
> /Flibble
>

Unlike the Liar Paradox, the Tarksi Undefinability Theorem sentence and
Gödel's 1931 Incompleteness Theorem sentence where the correct answer
to, is it true or false is neither, the Halting Problem counter-example
is provably non-halting.

typedef void (*ptr)();
int H(ptr p, ptr i); // simulating halt decider

// P does the opposite of whatever H decides
void P(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status) // if H(P,P) reports that its input halts
HERE: goto HERE; // P loops and never halts
return; // else P halts
}

P specifies non-halting behavior to every simulating halt decider H
because P continues to call H to simulate it again until H aborts its
simulation of P.

*This is easily verified with my fully operational halt decider*

Complete halt deciding system (Visual Studio Project)
(a) x86utm operating system
(b) Complete x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c

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

### olcott

Oct 1, 2022, 2:04:02 PMOct 1
to
On 10/1/2022 12:45 PM, Paul N wrote:
> On Saturday, October 1, 2022 at 4:09:20 PM UTC+1, olcott wrote:
>> Unlike the Liar Paradox, the Tarksi Undefinability Theorem sentence and
>> Gödel's 1931 Incompleteness Theorem sentence where the correct answer
>> to, is it true or false is neither, the Halting Problem counter-example
>> is provably non-halting.
>>
>> typedef void (*ptr)();
>> int H(ptr p, ptr i); // simulating halt decider
>>
>> // P does the opposite of whatever H decides
>> void P(ptr x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status) // if H(P,P) reports that its input halts
>> HERE: goto HERE; // P loops and never halts
>> return; // else P halts
>> }
>>
>> P specifies non-halting behavior to every simulating halt decider H
>> because P continues to call H to simulate it again until H aborts its
>> simulation of P.
>
> How can you yet again completely fail to spot that this won't work,

You acknowledged that it does work...

On 7/24/2022 6:19 PM, Paul N wrote:
> On Monday, July 25, 2022 at 12:10:34 AM UTC+1, olcott wrote:
>> If a simulating halt decider continues to correctly
>> simulate its input until it correctly matches a non-halting
>> behavior pattern then this SHD is necessarily correct when
>> it aborts its simulation and reports non-halting.
>
> Yes, *If* a simulating halt decider continues to correctly
> simulate its input until it *correctly* matches a non-
> halting behaviour pattern then this SHD is correct when it
> aborts its simulation and reports non-halting.

typedef void (*ptr)();

// P does the opposite of whatever H decides
void P(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status) // if H(P,P) reports that its input halts
HERE: goto HERE; // P loops and never halts
return; // else P halts
}

// This H(P,P) directly executes P(P) and is non-halting.
// and is an input to H
//
int H(ptr x, ptr y)
{
x(y);
}

int main() { P(P); } is not an input to H(P,P) thus is irrelevant to H
when it computes the mapping from its inputs...