4 views

Skip to first unread message

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

https://liarparadox.org/2022_09_07.zip

--

Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;

Genius hits a target no one else can see." Arthur Schopenhauer

> 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

https://liarparadox.org/2022_09_07.zip

--

Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;

Genius hits a target no one else can see." Arthur Schopenhauer

Oct 1, 2022, 2:04:02 PMOct 1

to

On 10/1/2022 12:45 PM, Paul N wrote:

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...

> 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,
>> 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.

>

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

}

// 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...

Oct 18, 2022, 4:31:08 PMOct 18

to

Reply all

Reply to author

Forward

0 new messages

Search

Clear search

Close search

Google apps

Main menu