Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.theory > #28415 > unrolled thread

Detecting infinite recursion (V2)

Started byolcott <NoOne@NoWhere.com>
First post2021-03-04 08:51 -0600
Last post2021-03-04 19:40 -0600
Articles 20 on this page of 70 — 9 participants

Back to article view | Back to comp.theory


Contents

  Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 08:51 -0600
    Re: Detecting infinite recursion (V2) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 10:55 -0500
      Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 10:04 -0600
        Re: Detecting infinite recursion (V2) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 11:17 -0500
          Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 10:29 -0600
            Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 11:44 -0500
              Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 11:12 -0600
                Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 13:17 -0500
                  Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 12:27 -0600
                    Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 14:08 -0500
                      Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 13:17 -0600
                        Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 14:43 -0500
                          Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 14:09 -0600
                            Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 15:58 -0500
                      Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 13:31 -0600
                        Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 14:47 -0500
                          Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) olcott <NoOne@NoWhere.com> - 2021-03-04 14:10 -0600
                            Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 16:04 -0500
                              Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem)(no inconsistency) olcott <NoOne@NoWhere.com> - 2021-03-04 15:20 -0600
                                Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem)(no inconsistency) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 17:34 -0500
                  Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-03-04 19:40 +0000
            Re: Detecting infinite recursion (V2)(removing pathological self-reference from the halting problem) Peter <peterxpercival@hotmail.com> - 2021-03-04 16:55 +0000
    Re: Detecting infinite recursion (V2) David Brown <david.brown@hesbynett.no> - 2021-03-04 16:59 +0100
      Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 10:08 -0600
        Re: Detecting infinite recursion (V2) David Brown <david.brown@hesbynett.no> - 2021-03-04 17:39 +0100
          Re: Detecting infinite recursion (V2) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 11:58 -0500
          Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 11:22 -0600
      Re: Detecting infinite recursion (V2) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 11:24 -0500
    Re: Detecting infinite recursion (V2) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-04 19:21 +0000
      Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 13:38 -0600
        Re: Detecting infinite recursion (V2) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 14:49 -0500
          Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 14:12 -0600
            Re: Detecting infinite recursion (V2) Richard Damon <Richard@Damon-Family.org> - 2021-03-04 16:06 -0500
        Re: Detecting infinite recursion (V2) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-03-04 21:15 +0000
          Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 15:23 -0600
          Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 15:48 -0600
    Re: Detecting infinite recursion (V2) R Kym Horsell <kym@kymhorsell.com> - 2021-03-04 21:22 +0000
      Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 15:32 -0600
        Re: Detecting infinite recursion (V2) Alan Mackenzie <acm@muc.de> - 2021-03-04 22:54 +0000
          Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 17:31 -0600
            Re: Detecting infinite recursion (V2) Alan Mackenzie <acm@muc.de> - 2021-03-05 09:19 +0000
              Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-05 08:32 -0600
                Re: Detecting infinite recursion (V2) Alan Mackenzie <acm@muc.de> - 2021-03-05 14:53 +0000
                  Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-05 09:26 -0600
                    Re: Detecting infinite recursion (V2) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 16:42 +0000
                      Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 11:02 -0600
                        Re: Deciding the [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 21:02 +0000
                          Re: Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-05 15:15 -0600
                            Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-05 20:42 -0500
                            Re: Deciding the [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-06 23:43 +0000
                              Re: Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-06 18:00 -0600
                              Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-06 19:33 -0500
                                Re: Deciding the [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 00:38 +0000
                                  Re: Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-06 18:53 -0600
                                    Re: Deciding the [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 01:15 +0000
                                      Re: Deciding the [would-not-halt] property olcott <NoOne@NoWhere.com> - 2021-03-06 19:26 -0600
                                        Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-06 21:01 -0500
                                          Re: Deciding the [would-not-halt] property (Undecidability == error) olcott <NoOne@NoWhere.com> - 2021-03-06 20:08 -0600
                                            Re: Deciding the [would-not-halt] property (Undecidability == error) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 22:00 -0500
                                              Re: Deciding the [would-not-halt] property (Undecidability == error) olcott <NoOne@NoWhere.com> - 2021-03-06 21:16 -0600
                                                Re: Deciding the [would-not-halt] property (Undecidability == error) Richard Damon <Richard@Damon-Family.org> - 2021-03-06 23:02 -0500
                                                  Re: Deciding the [would-not-halt] property (Undecidability == error) olcott <NoOne@NoWhere.com> - 2021-03-06 22:17 -0600
                                                    Re: Deciding the [would-not-halt] property (Undecidability == error) Richard Damon <Richard@Damon-Family.org> - 2021-03-07 09:30 -0500
                                                Re: Deciding the [would-not-halt] property (Undecidability == error) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 12:14 +0000
                                        Re: Deciding the [would-not-halt] property Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-07 12:06 +0000
                                    Re: Deciding the [would-not-halt] property Richard Damon <Richard@Damon-Family.org> - 2021-03-06 20:22 -0500
        Re: Detecting infinite recursion (V2) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 00:15 +0000
          Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 18:26 -0600
            Re: Detecting infinite recursion (V2) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-03-05 01:25 +0000
              Re: Detecting infinite recursion (V2) olcott <NoOne@NoWhere.com> - 2021-03-04 19:40 -0600

Page 3 of 4 — ← Prev page 1 2 [3] 4  Next page →


#28545

FromAlan Mackenzie <acm@muc.de>
Date2021-03-05 09:19 +0000
Message-ID<s1st2u$qeb$1@news.muc.de>
In reply to#28493
olcott <NoOne@nowhere.com> wrote:
> On 3/4/2021 4:54 PM, Alan Mackenzie wrote:
>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>> On 3/4/2021 3:22 PM, R Kym Horsell wrote:
>>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>> ...
>>>>> Can this Simulate() function correctly decide not halting on its
>>>>> input on the basis that it did correctly detect that it was being
>>>>> called in infinite recursion?

>>>> Since detecting infinite recursion is the same problem as the
>>>> halting problem we can all guess "no" and your thinking is still
>>>> hopelessly confused.


>>> Removing the pathological self-reference(Olcott 2004) from the
>>> halting problem by changing the halt deciding criteria:

>>> (a) Does the input program halt on its input?

>>> (b) Does the simulation of the input program have to be stopped to
>>> prevent its otherwise infinite execution?

>>> Provides the basis for dividing all inputs into those having the
>>> not-halting property and those that do not.

>> It does not.  In particular, your program, a purported universal
>> halting decider, won't correctly classify an input program constructed
>> to break it, à la Linz.

> I show 100% of every detail of all of the criteria used by Halts() to
> correctly decide halting of the equivalent of the Linz H_Hat(). You
> have to understand the x86 assembly language to understand these
> details.

I don't have to understand the details at all.  They are unimportant.
But all of them together build a purported universal halting detector.
Let's call it J, since H has been so overused recently.

From J, using the method of Linz, we can construct J^.  J fails correctly
to classify J^ as halting or non-halting.  Thus J is not a universal
halting detector.

That's all there is to it.

[ Snip details of J. ]

> -- 
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre 
> minds." Einstein

-- 
Alan Mackenzie (Nuremberg, Germany).

[toc] | [prev] | [next] | [standalone]


#28551

Fromolcott <NoOne@NoWhere.com>
Date2021-03-05 08:32 -0600
Message-ID<PJCdnf8-icuT3N_9nZ2dnUU7-TfNnZ2d@giganews.com>
In reply to#28545
On 3/5/2021 3:19 AM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>> On 3/4/2021 4:54 PM, Alan Mackenzie wrote:
>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>> On 3/4/2021 3:22 PM, R Kym Horsell wrote:
>>>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>>> ...
>>>>>> Can this Simulate() function correctly decide not halting on its
>>>>>> input on the basis that it did correctly detect that it was being
>>>>>> called in infinite recursion?
> 
>>>>> Since detecting infinite recursion is the same problem as the
>>>>> halting problem we can all guess "no" and your thinking is still
>>>>> hopelessly confused.
> 
> 
>>>> Removing the pathological self-reference(Olcott 2004) from the
>>>> halting problem by changing the halt deciding criteria:
> 
>>>> (a) Does the input program halt on its input?
> 
>>>> (b) Does the simulation of the input program have to be stopped to
>>>> prevent its otherwise infinite execution?
> 
>>>> Provides the basis for dividing all inputs into those having the
>>>> not-halting property and those that do not.
> 
>>> It does not.  In particular, your program, a purported universal
>>> halting decider, won't correctly classify an input program constructed
>>> to break it, à la Linz.
> 
>> I show 100% of every detail of all of the criteria used by Halts() to
>> correctly decide halting of the equivalent of the Linz H_Hat(). You
>> have to understand the x86 assembly language to understand these
>> details.
> 
> I don't have to understand the details at all.  They are unimportant.
> But all of them together build a purported universal halting detector.

See there that's what you get for not understanding what I said.
None of them build any universal halt decider.

> Let's call it J, since H has been so overused recently.
> 
>  From J, using the method of Linz, we can construct J^.  J fails correctly
> to classify J^ as halting or non-halting.  Thus J is not a universal
> halting detector.

See there you go again making false assumptions on the basis of not 
bothering to understand what I am actually saying.

http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
Using the Linz naming conventions:

H(Ĥ, Ĥ) then H halts in its reject state deciding that Ĥ(Ĥ) has the 
non-halting property.

> That's all there is to it.
> 
> [ Snip details of J. ]
> 
>> -- 
>> Copyright 2021 Pete Olcott
> 
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28554

FromAlan Mackenzie <acm@muc.de>
Date2021-03-05 14:53 +0000
Message-ID<s1tgl8$1oka$1@news.muc.de>
In reply to#28551
olcott <NoOne@nowhere.com> wrote:
> On 3/5/2021 3:19 AM, Alan Mackenzie wrote:
>> olcott <NoOne@nowhere.com> wrote:
>>> On 3/4/2021 4:54 PM, Alan Mackenzie wrote:
>>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>>> On 3/4/2021 3:22 PM, R Kym Horsell wrote:
>>>>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>>>> ...
>>>>>>> Can this Simulate() function correctly decide not halting on its
>>>>>>> input on the basis that it did correctly detect that it was being
>>>>>>> called in infinite recursion?

>>>>>> Since detecting infinite recursion is the same problem as the
>>>>>> halting problem we can all guess "no" and your thinking is still
>>>>>> hopelessly confused.


>>>>> Removing the pathological self-reference(Olcott 2004) from the
>>>>> halting problem by changing the halt deciding criteria:

>>>>> (a) Does the input program halt on its input?

>>>>> (b) Does the simulation of the input program have to be stopped to
>>>>> prevent its otherwise infinite execution?

>>>>> Provides the basis for dividing all inputs into those having the
>>>>> not-halting property and those that do not.

>>>> It does not.  In particular, your program, a purported universal
>>>> halting decider, won't correctly classify an input program constructed
>>>> to break it, à la Linz.

>>> I show 100% of every detail of all of the criteria used by Halts() to
>>> correctly decide halting of the equivalent of the Linz H_Hat(). You
>>> have to understand the x86 assembly language to understand these
>>> details.

>> I don't have to understand the details at all.  They are unimportant.
>> But all of them together build a purported universal halting detector.

> See there that's what you get for not understanding what I said.
> None of them build any universal halt decider.

>> Let's call it J, since H has been so overused recently.

>>  From J, using the method of Linz, we can construct J^.  J fails correctly
>> to classify J^ as halting or non-halting.  Thus J is not a universal
>> halting detector.

> See there you go again making false assumptions on the basis of not 
> bothering to understand what I am actually saying.

Understanding what you are actually saying can be difficult, since you
rarely write with clarity in mind.  What you actually wrote was (it's
still above in the quoted text):

>>>>> Removing the pathological self-reference(Olcott 2004) from the
>>>>> halting problem by changing the halt deciding criteria:
>>>>> ....
>>>>> Provides the basis for dividing all inputs into those having the
>>>>> not-halting property and those that do not.

That, to me, looks like a claim to a universal halting decider.  The
English syntax is a bit dodgy, but the claim is there and clear.  You
clearly say "ALL inputs".

Or do you now accept that a universal halting decider is impossible?

> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
> Using the Linz naming conventions:

> H(Ĥ, Ĥ) then H halts in its reject state deciding that Ĥ(Ĥ) has the 
> non-halting property.

>> That's all there is to it.

[ .... ]

> -- 
> Copyright 2021 Pete Olcott

> "Great spirits have always encountered violent opposition from mediocre 
> minds." Einstein

-- 
Alan Mackenzie (Nuremberg, Germany).

[toc] | [prev] | [next] | [standalone]


#28560

Fromolcott <NoOne@NoWhere.com>
Date2021-03-05 09:26 -0600
Message-ID<dc2dnWu2954a0N_9nZ2dnUU7-IXNnZ2d@giganews.com>
In reply to#28554
On 3/5/2021 8:53 AM, Alan Mackenzie wrote:
> olcott <NoOne@nowhere.com> wrote:
>> On 3/5/2021 3:19 AM, Alan Mackenzie wrote:
>>> olcott <NoOne@nowhere.com> wrote:
>>>> On 3/4/2021 4:54 PM, Alan Mackenzie wrote:
>>>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>>>> On 3/4/2021 3:22 PM, R Kym Horsell wrote:
>>>>>>> In comp.theory olcott <NoOne@nowhere.com> wrote:
>>>>>>> ...
>>>>>>>> Can this Simulate() function correctly decide not halting on its
>>>>>>>> input on the basis that it did correctly detect that it was being
>>>>>>>> called in infinite recursion?
> 
>>>>>>> Since detecting infinite recursion is the same problem as the
>>>>>>> halting problem we can all guess "no" and your thinking is still
>>>>>>> hopelessly confused.
> 
> 
>>>>>> Removing the pathological self-reference(Olcott 2004) from the
>>>>>> halting problem by changing the halt deciding criteria:
> 
>>>>>> (a) Does the input program halt on its input?
> 
>>>>>> (b) Does the simulation of the input program have to be stopped to
>>>>>> prevent its otherwise infinite execution?
> 
>>>>>> Provides the basis for dividing all inputs into those having the
>>>>>> not-halting property and those that do not.
> 
>>>>> It does not.  In particular, your program, a purported universal
>>>>> halting decider, won't correctly classify an input program constructed
>>>>> to break it, à la Linz.
> 
>>>> I show 100% of every detail of all of the criteria used by Halts() to
>>>> correctly decide halting of the equivalent of the Linz H_Hat(). You
>>>> have to understand the x86 assembly language to understand these
>>>> details.
> 
>>> I don't have to understand the details at all.  They are unimportant.
>>> But all of them together build a purported universal halting detector.
> 
>> See there that's what you get for not understanding what I said.
>> None of them build any universal halt decider.
> 
>>> Let's call it J, since H has been so overused recently.
> 
>>>   From J, using the method of Linz, we can construct J^.  J fails correctly
>>> to classify J^ as halting or non-halting.  Thus J is not a universal
>>> halting detector.
> 
>> See there you go again making false assumptions on the basis of not
>> bothering to understand what I am actually saying.
> 
> Understanding what you are actually saying can be difficult, since you
> rarely write with clarity in mind.  What you actually wrote was (it's
> still above in the quoted text):
> 
>>>>>> Removing the pathological self-reference(Olcott 2004) from the
>>>>>> halting problem by changing the halt deciding criteria:
>>>>>> ....
>>>>>> Provides the basis for dividing all inputs into those having the
>>>>>> not-halting property and those that do not.
> 
> That, to me, looks like a claim to a universal halting decider.  The
> English syntax is a bit dodgy, but the claim is there and clear.  You
> clearly say "ALL inputs".
> 
> Or do you now accept that a universal halting decider is impossible?

I have proved that a universal halt decider is no longer proved to be 
impossible by showing all the details of how:

void H_Hat(u32 P)
{
  u32 Input_Halts = Halts(P, P);
   if (Input_Halts)
     HERE: goto HERE;
   return;
}

int main()
{
   u32 Input_Would_Halt = Halts((u32)H_Hat, (u32)H_Hat);
   Output("Input_Would_Halt = ", Input_Would_Halt);
}

is correctly decided as non-halting.

>> http://www.liarparadox.org/Peter_Linz_HP(Pages_315-320).pdf
>> Using the Linz naming conventions:
> 
>> H(Ĥ, Ĥ) then H halts in its reject state deciding that Ĥ(Ĥ) has the
>> non-halting property.
> 
>>> That's all there is to it.
> 
> [ .... ]
> 
>> -- 
>> Copyright 2021 Pete Olcott
> 
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28574

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-03-05 16:42 +0000
Message-ID<87k0qlh7ry.fsf@bsb.me.uk>
In reply to#28560
olcott <NoOne@NoWhere.com> writes:

> On 3/5/2021 8:53 AM, Alan Mackenzie wrote:

>> Or do you now accept that a universal halting decider is impossible?
>
> I have proved that a universal halt decider is no longer proved to be
> impossible

You have invented your own notion of what you consider to be a halting
computation.  Every time you use the term "halting" from now on you are
being dishonest.  If you keep doing it, you are just being a dishonest
jerk.  Don't be either.  (By the way, you need to qualify your uses of
"decider" as well since you don't use the conventional meaning.)

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#28576 — Deciding the [would-not-halt] property

Fromolcott <NoOne@NoWhere.com>
Date2021-03-05 11:02 -0600
SubjectDeciding the [would-not-halt] property
Message-ID<SqSdnT_tuJWX-d_9nZ2dnUU7-QOdnZ2d@giganews.com>
In reply to#28574
On 3/5/2021 10:42 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 3/5/2021 8:53 AM, Alan Mackenzie wrote:
> 
>>> Or do you now accept that a universal halting decider is impossible?
>>
>> I have proved that a universal halt decider is no longer proved to be
>> impossible
> 
> You have invented your own notion of what you consider to be a halting
> computation.  Every time you use the term "halting" from now on you are
> being dishonest.  If you keep doing it, you are just being a dishonest
> jerk.  Don't be either.  (By the way, you need to qualify your uses of
> "decider" as well since you don't use the conventional meaning.)
> 

A computation has the [would-not-halt] property if any anytime during 
its execution trace it would not halt unless its execution was aborted.

This same [would-not-halt] property also applies to (at least partial) 
halt deciders that base their halting decision on examining their own 
execution trace of their input to determine whether or not this input 
has the [would-not-halt] property.

When an (at least partial) halt decider determines that its input has 
the [would-not-halt] property it terminates the simulation of its input 
and decides [would-not-halt].


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28586 — Re: Deciding the [would-not-halt] property

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-03-05 21:02 +0000
SubjectRe: Deciding the [would-not-halt] property
Message-ID<87r1ktfh5b.fsf@bsb.me.uk>
In reply to#28576
olcott <NoOne@NoWhere.com> writes:

> On 3/5/2021 10:42 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/5/2021 8:53 AM, Alan Mackenzie wrote:
>>
>>>> Or do you now accept that a universal halting decider is impossible?
>>>
>>> I have proved that a universal halt decider is no longer proved to be
>>> impossible
>>
>> You have invented your own notion of what you consider to be a halting
>> computation.  Every time you use the term "halting" from now on you are
>> being dishonest.  If you keep doing it, you are just being a dishonest
>> jerk.  Don't be either.  (By the way, you need to qualify your uses of
>> "decider" as well since you don't use the conventional meaning.)
>>
>
> A computation has the [would-not-halt] property if any anytime during
> its execution trace it would not halt unless its execution was
> aborted.

Thank you for qualifying the term "halt", but I think you've got it
wrong.  If I remove the words I can't understand "any anytime during its
execution trace" (I know the "any" is a typo) then it's just plain old
ordinary halting, not PO-halting.  And I can't see how that mystery
phrase alters the meaning to give the one you are really using.

If, somehow, this does reflect your "some other computation is non
halting so this halting one can be called non-halting" definition, I
don't think [would-not-halt] is a good name but you are always resistant
to naming suggestions.  Anything but halting is an improvement.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#28587 — Re: Deciding the [would-not-halt] property

Fromolcott <NoOne@NoWhere.com>
Date2021-03-05 15:15 -0600
SubjectRe: Deciding the [would-not-halt] property
Message-ID<oc2dnTM49uvhAt_9nZ2dnUU7-TnNnZ2d@giganews.com>
In reply to#28586
On 3/5/2021 3:02 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> On 3/5/2021 10:42 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/5/2021 8:53 AM, Alan Mackenzie wrote:
>>>
>>>>> Or do you now accept that a universal halting decider is impossible?
>>>>
>>>> I have proved that a universal halt decider is no longer proved to be
>>>> impossible
>>>
>>> You have invented your own notion of what you consider to be a halting
>>> computation.  Every time you use the term "halting" from now on you are
>>> being dishonest.  If you keep doing it, you are just being a dishonest
>>> jerk.  Don't be either.  (By the way, you need to qualify your uses of
>>> "decider" as well since you don't use the conventional meaning.)
>>>
>>
>> A computation has the [would-not-halt] property if any anytime during
>> its execution trace it would not halt unless its execution was
>> aborted.
> 
> Thank you for qualifying the term "halt", but I think you've got it
> wrong.  If I remove the words I can't understand "any anytime during its
> execution trace" (I know the "any" is a typo) then it's just plain old
> ordinary halting, not PO-halting.  And I can't see how that mystery
> phrase alters the meaning to give the one you are really using.

The halt decider decides that if the input program was directly executed
by a pure simulator that had no halt deciding capabilities that the
input program would execute infinitely.

> If, somehow, this does reflect your "some other computation is non
> halting so this halting one can be called non-halting" definition, I
> don't think [would-not-halt] is a good name but you are always resistant
> to naming suggestions.  Anything but halting is an improvement.
> 


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28608 — Re: Deciding the [would-not-halt] property

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-05 20:42 -0500
SubjectRe: Deciding the [would-not-halt] property
Message-ID<66B0I.44566$2o1.33655@fx27.iad>
In reply to#28587
On 3/5/21 4:15 PM, olcott wrote:
> 
> The halt decider decides that if the input program was directly executed
> by a pure simulator that had no halt deciding capabilities that the
> input program would execute infinitely.

And this is part of your problem.

First, because for this analysis you appear to change ALL the
occurrences of Halt Deciders into Simulators, you actually end up making
your decision on the wrong computation.

Yes, a H_Hat built on a Simulator instead of a Halt Decider has infinite
execution, but that doesn't mean that the same applies when the Halt
Decider actually works.

While it may be arguable for H_Hat, since it includes the possibility of
an infinte loop in the local body of the code, it says that you make
that same prediction for code that is clearly finite, like a machine
define something like:

u32 test(u32 P) {
    return Halt(P, P);
}

This computation should have the identical halting behavior as your Halt
Decider, but test(test) will be reported an non-halting

Second, you are only able to implement this test because you have
limited the capability of the halt decider to require all the programs
to start in the same memory space, and thus it is NOT based on a
mechanism as powerful as a real UTM.

As I pointed out previously, if you build H_Hat per the proof
specification where it REAL DOES make a copy of itself (requiring it to
be compiled as position independent code due to your bug), your Decider
will not be able to detect the recursion and just eventual die from
running out of memory.

This fact also invalidates your 'proof'.

[toc] | [prev] | [next] | [standalone]


#28696 — Re: Deciding the [would-not-halt] property

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-03-06 23:43 +0000
SubjectRe: Deciding the [would-not-halt] property
Message-ID<87mtvfdf0r.fsf@bsb.me.uk>
In reply to#28587
olcott <NoOne@NoWhere.com> writes:

> The halt decider decides that if the input program was directly executed
> by a pure simulator that had no halt deciding capabilities that the
> input program would execute infinitely.

This is conventional halting, as everyone understands it, only phrased
in a silly way.  A halting program ("computation" would be better) is
one that does not halt.  There is no need to state this in terms of what
a simulation of it would do because, as you have quoted me 1,278 times,
a computation and it's (correct) simulation must have the same halting
status.

There is no algorithm to determine this property.

You have, in the past, been able to be clear about your new (and daft)
PO-halting, but this is not how to state it.  Go back to the code you
posted in response to my challenge last year.  That makes PO-halting
completely clear.

PO-halting is also impossible to determine (in general), but it does
work in the case you keep obsessing about, because you declare
"non-halting" to be the correct status to report for some halting
computations.  That'll do it every time!

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#28697 — Re: Deciding the [would-not-halt] property

Fromolcott <NoOne@NoWhere.com>
Date2021-03-06 18:00 -0600
SubjectRe: Deciding the [would-not-halt] property
Message-ID<s5GdnbkNjefoitn9nZ2dnUU78WXNnZ2d@giganews.com>
In reply to#28696
On 3/6/2021 5:43 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> The halt decider decides that if the input program was directly executed
>> by a pure simulator that had no halt deciding capabilities that the
>> input program would execute infinitely.
> 
> This is conventional halting, as everyone understands it, only phrased
> in a silly way.  A halting program ("computation" would be better) is
> one that does not halt.  There is no need to state this in terms of what
> a simulation of it would do because, as you have quoted me 1,278 times,
> a computation and it's (correct) simulation must have the same halting
> status.
> 
> There is no algorithm to determine this property.
> 
> You have, in the past, been able to be clear about your new (and daft)
> PO-halting, but this is not how to state it.  Go back to the code you
> posted in response to my challenge last year.  That makes PO-halting
> completely clear.
> 
> PO-halting is also impossible to determine (in general), but it does
> work in the case you keep obsessing about, because you declare
> "non-halting" to be the correct status to report for some halting
> computations.  That'll do it every time!
> 

Every (at least partial) halt decider that decides the halting status of 
its input on the basis of its examination of the execution trace of its 
own simulation of this input would decide that the conventional halting 
problem counter-examples would not halt unless the halt decider stopped 
its simulation of these counter-examples.

http://www.liarparadox.org/Eliminating_pathological_self_reference_error_from_the_halting_problem.pdf


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28701 — Re: Deciding the [would-not-halt] property

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-06 19:33 -0500
SubjectRe: Deciding the [would-not-halt] property
Message-ID<ebV0I.275888$pZ.270566@fx40.iad>
In reply to#28696
On 3/6/21 6:43 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> The halt decider decides that if the input program was directly executed
>> by a pure simulator that had no halt deciding capabilities that the
>> input program would execute infinitely.
> 
> This is conventional halting, as everyone understands it, only phrased
> in a silly way.  A halting program ("computation" would be better) is
> one that does not halt.  There is no need to state this in terms of what
> a simulation of it would do because, as you have quoted me 1,278 times,
> a computation and it's (correct) simulation must have the same halting
> status.
> 
> There is no algorithm to determine this property.
> 
> You have, in the past, been able to be clear about your new (and daft)
> PO-halting, but this is not how to state it.  Go back to the code you
> posted in response to my challenge last year.  That makes PO-halting
> completely clear.
> 
> PO-halting is also impossible to determine (in general), but it does
> work in the case you keep obsessing about, because you declare
> "non-halting" to be the correct status to report for some halting
> computations.  That'll do it every time!
> 

The issue with his logic is that it seems that he first turns all halt
deciders into just simulators, and then sees if that computation (which
is different) is non-halting, and if that one is, he calls the original
computation non-halting or if pushed hard needed-to-be-halted.

He dues this by/because he ignores the conditional code of the halt
decider when testing for looping.

Thus, he blames Bob for the deeds of Bill.

[toc] | [prev] | [next] | [standalone]


#28704 — Re: Deciding the [would-not-halt] property

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-03-07 00:38 +0000
SubjectRe: Deciding the [would-not-halt] property
Message-ID<87eegrdchg.fsf@bsb.me.uk>
In reply to#28701
Richard Damon <Richard@Damon-Family.org> writes:

> On 3/6/21 6:43 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> The halt decider decides that if the input program was directly executed
>>> by a pure simulator that had no halt deciding capabilities that the
>>> input program would execute infinitely.
>> 
>> This is conventional halting, as everyone understands it, only phrased
>> in a silly way.  A halting program ("computation" would be better) is
>> one that does not halt.  There is no need to state this in terms of what
>> a simulation of it would do because, as you have quoted me 1,278 times,
>> a computation and it's (correct) simulation must have the same halting
>> status.
>> 
>> There is no algorithm to determine this property.
>> 
>> You have, in the past, been able to be clear about your new (and daft)
>> PO-halting, but this is not how to state it.  Go back to the code you
>> posted in response to my challenge last year.  That makes PO-halting
>> completely clear.
>> 
>> PO-halting is also impossible to determine (in general), but it does
>> work in the case you keep obsessing about, because you declare
>> "non-halting" to be the correct status to report for some halting
>> computations.  That'll do it every time!
>
> The issue with his logic is that it seems that he first turns all halt
> deciders into just simulators, and then sees if that computation (which
> is different) is non-halting, and if that one is, he calls the original
> computation non-halting or if pushed hard needed-to-be-halted.

Yes.  He's been (in the past) clear about that.  Everything recent has
been trying to hide what he means by "halting".  He needs fuzzy words to
obscure this simple trick.  There's the weird use of the subjunctive,
the anthropomorphisation of computations, and the notion that the whole
this is "semantically incoherent".

> He dues this by/because he ignores the conditional code of the halt
> decider when testing for looping.
>
> Thus, he blames Bob for the deeds of Bill.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#28707 — Re: Deciding the [would-not-halt] property

Fromolcott <NoOne@NoWhere.com>
Date2021-03-06 18:53 -0600
SubjectRe: Deciding the [would-not-halt] property
Message-ID<d5udnZfQQ4B0vtn9nZ2dnUU7-aGdnZ2d@giganews.com>
In reply to#28704
On 3/6/2021 6:38 PM, Ben Bacarisse wrote:
> Richard Damon <Richard@Damon-Family.org> writes:
> 
>> On 3/6/21 6:43 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> The halt decider decides that if the input program was directly executed
>>>> by a pure simulator that had no halt deciding capabilities that the
>>>> input program would execute infinitely.
>>>
>>> This is conventional halting, as everyone understands it, only phrased
>>> in a silly way.  A halting program ("computation" would be better) is
>>> one that does not halt.  There is no need to state this in terms of what
>>> a simulation of it would do because, as you have quoted me 1,278 times,
>>> a computation and it's (correct) simulation must have the same halting
>>> status.
>>>
>>> There is no algorithm to determine this property.
>>>
>>> You have, in the past, been able to be clear about your new (and daft)
>>> PO-halting, but this is not how to state it.  Go back to the code you
>>> posted in response to my challenge last year.  That makes PO-halting
>>> completely clear.
>>>
>>> PO-halting is also impossible to determine (in general), but it does
>>> work in the case you keep obsessing about, because you declare
>>> "non-halting" to be the correct status to report for some halting
>>> computations.  That'll do it every time!
>>
>> The issue with his logic is that it seems that he first turns all halt
>> deciders into just simulators, and then sees if that computation (which
>> is different) is non-halting, and if that one is, he calls the original
>> computation non-halting or if pushed hard needed-to-be-halted.
> 
> Yes.  He's been (in the past) clear about that.  Everything recent has
> been trying to hide what he means by "halting".  He needs fuzzy words to
> obscure this simple trick.  There's the weird use of the subjunctive,
> the anthropomorphisation of computations, and the notion that the whole
> this is "semantically incoherent".
> 
>> He dues this by/because he ignores the conditional code of the halt
>> decider when testing for looping.
>>
>> Thus, he blames Bob for the deeds of Bill.
> 

All that I am doing at this point is proving that the original halt 
deciding criteria defines an incorrect decision problem. This would be 
far too much for rigid learned by rote minds to ever accept.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28714 — Re: Deciding the [would-not-halt] property

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-03-07 01:15 +0000
SubjectRe: Deciding the [would-not-halt] property
Message-ID<87im63bw77.fsf@bsb.me.uk>
In reply to#28707
olcott <NoOne@NoWhere.com> writes:

> All that I am doing at this point is proving that the original halt
> deciding criteria defines an incorrect decision problem.

That's not what you said you were doing two years ago.  Were you wrong
back then?

What in PO-land is an incorrect decision problem?  The halting problem
is simply that of deciding if a computation halts or not.  There's
nothing even remotely "incorrect" about that.

-- 
Ben.

[toc] | [prev] | [next] | [standalone]


#28717 — Re: Deciding the [would-not-halt] property

Fromolcott <NoOne@NoWhere.com>
Date2021-03-06 19:26 -0600
SubjectRe: Deciding the [would-not-halt] property
Message-ID<19qdncc4zLc2ttn9nZ2dnUU7-IHNnZ2d@giganews.com>
In reply to#28714
On 3/6/2021 7:15 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> All that I am doing at this point is proving that the original halt
>> deciding criteria defines an incorrect decision problem.
> 
> That's not what you said you were doing two years ago.  Were you wrong
> back then?

All that I am doing at this point
All that I am doing at this point
All that I am doing at this point
All that I am doing at this point

Are you aware that this point in time is not the same point in time as 
two years ago?

> What in PO-land is an incorrect decision problem?  The halting problem
> is simply that of deciding if a computation halts or not.  There's
> nothing even remotely "incorrect" about that.

An incorrect decision problem is simply the formal language equivalent 
of the natural language incorrect question.

Every yes/no question that cannot possibly be resolved to yes or no is 
an incorrect question.

Incorrect decision problems are typically called undecidable decision 
problems. Most people never notice that the only reason that they are 
undecidable is that there is something wrong with them.

Every decision problem that cannot possibly be resolved to true or false 
is an incorrect decision problem.


-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28723 — Re: Deciding the [would-not-halt] property

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-06 21:01 -0500
SubjectRe: Deciding the [would-not-halt] property
Message-ID<ztW0I.6979$%k1.5287@fx15.iad>
In reply to#28717
On 3/6/21 8:26 PM, olcott wrote:
> On 3/6/2021 7:15 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> All that I am doing at this point is proving that the original halt
>>> deciding criteria defines an incorrect decision problem.
>>
>> That's not what you said you were doing two years ago.  Were you wrong
>> back then?
> 
> All that I am doing at this point
> All that I am doing at this point
> All that I am doing at this point
> All that I am doing at this point
> 
> Are you aware that this point in time is not the same point in time as
> two years ago?
> 
>> What in PO-land is an incorrect decision problem?  The halting problem
>> is simply that of deciding if a computation halts or not.  There's
>> nothing even remotely "incorrect" about that.
> 
> An incorrect decision problem is simply the formal language equivalent
> of the natural language incorrect question.
> 
> Every yes/no question that cannot possibly be resolved to yes or no is
> an incorrect question.
> 
> Incorrect decision problems are typically called undecidable decision
> problems. Most people never notice that the only reason that they are
> undecidable is that there is something wrong with them.
> 
> Every decision problem that cannot possibly be resolved to true or false
> is an incorrect decision problem.
> 
> 

Except that the question that can not be resolved is NOT the question of
the Halting problem.

The Halting Problem ALWAYS has a right answer.

It is just that since a Halt Decider needs to be a computation that is
in existence, it can be shown that there is at least one computation
(that happens to be based on it) that it can not answer correctly.

There is still a right answer.

[toc] | [prev] | [next] | [standalone]


#28724 — Re: Deciding the [would-not-halt] property (Undecidability == error)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-06 20:08 -0600
SubjectRe: Deciding the [would-not-halt] property (Undecidability == error)
Message-ID<5PadnaF3KsEaqNn9nZ2dnUU7-b3NnZ2d@giganews.com>
In reply to#28723
On 3/6/2021 8:01 PM, Richard Damon wrote:
> On 3/6/21 8:26 PM, olcott wrote:
>> On 3/6/2021 7:15 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> All that I am doing at this point is proving that the original halt
>>>> deciding criteria defines an incorrect decision problem.
>>>
>>> That's not what you said you were doing two years ago.  Were you wrong
>>> back then?
>>
>> All that I am doing at this point
>> All that I am doing at this point
>> All that I am doing at this point
>> All that I am doing at this point
>>
>> Are you aware that this point in time is not the same point in time as
>> two years ago?
>>
>>> What in PO-land is an incorrect decision problem?  The halting problem
>>> is simply that of deciding if a computation halts or not.  There's
>>> nothing even remotely "incorrect" about that.
>>
>> An incorrect decision problem is simply the formal language equivalent
>> of the natural language incorrect question.
>>
>> Every yes/no question that cannot possibly be resolved to yes or no is
>> an incorrect question.
>>
>> Incorrect decision problems are typically called undecidable decision
>> problems. Most people never notice that the only reason that they are
>> undecidable is that there is something wrong with them.
>>
>> Every decision problem that cannot possibly be resolved to true or false
>> is an incorrect decision problem.
>>
>>
> 
> Except that the question that can not be resolved is NOT the question of
> the Halting problem.
> 
> The Halting Problem ALWAYS has a right answer.

If there are any undecidable inputs this by itself proves that the 
halting problem is an incorrect decision problem.

Undecidability always means error.
That you fail to understand this does not make it not true.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


#28727 — Re: Deciding the [would-not-halt] property (Undecidability == error)

FromRichard Damon <Richard@Damon-Family.org>
Date2021-03-06 22:00 -0500
SubjectRe: Deciding the [would-not-halt] property (Undecidability == error)
Message-ID<RkX0I.231150$h21.168902@fx48.iad>
In reply to#28724
On 3/6/21 9:08 PM, olcott wrote:
> On 3/6/2021 8:01 PM, Richard Damon wrote:
>> On 3/6/21 8:26 PM, olcott wrote:
>>> On 3/6/2021 7:15 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> All that I am doing at this point is proving that the original halt
>>>>> deciding criteria defines an incorrect decision problem.
>>>>
>>>> That's not what you said you were doing two years ago.  Were you wrong
>>>> back then?
>>>
>>> All that I am doing at this point
>>> All that I am doing at this point
>>> All that I am doing at this point
>>> All that I am doing at this point
>>>
>>> Are you aware that this point in time is not the same point in time as
>>> two years ago?
>>>
>>>> What in PO-land is an incorrect decision problem?  The halting problem
>>>> is simply that of deciding if a computation halts or not.  There's
>>>> nothing even remotely "incorrect" about that.
>>>
>>> An incorrect decision problem is simply the formal language equivalent
>>> of the natural language incorrect question.
>>>
>>> Every yes/no question that cannot possibly be resolved to yes or no is
>>> an incorrect question.
>>>
>>> Incorrect decision problems are typically called undecidable decision
>>> problems. Most people never notice that the only reason that they are
>>> undecidable is that there is something wrong with them.
>>>
>>> Every decision problem that cannot possibly be resolved to true or false
>>> is an incorrect decision problem.
>>>
>>>
>>
>> Except that the question that can not be resolved is NOT the question of
>> the Halting problem.
>>
>> The Halting Problem ALWAYS has a right answer.
> 
> If there are any undecidable inputs this by itself proves that the
> halting problem is an incorrect decision problem.
> 
> Undecidability always means error.
> That you fail to understand this does not make it not true.
> 

Note, the undecidable question is NOT the question of the Halting
Problem, so that isn't the issue.

There is ALWAYS a definite answer (might not be knowable, but there is
an answer) to the question if a given computation is finite or not.

The question that sometimes can't be answered is what answer does a give
halt decider that is part of a computation need to make to answer the
halting property of that calculation. This is because the 'outer' part
of the calculation is able to 'game' the system so that the decider will
always be wrong. That calculation still has a definite answer to the
halting problem, given that the halt decider IS  an actual calculation
as it needs to be.

This is like the question of what is my winning move at NIM, and
sometimes the answer is that the game is against you and you can't win.
That doesn't make the game an error, it just means that you lost. (Maybe
the game is rigged, or maybe you made an error previously).

If your problem is that the definite answer might not be knowable, then
you are still wrong. It HAS been proved that in any sufficiently
complicated system of logic (and being able to handle the Natural
Numbers is enough) there exists some true statements that can not be
proven by any formal system of logic.

[toc] | [prev] | [next] | [standalone]


#28730 — Re: Deciding the [would-not-halt] property (Undecidability == error)

Fromolcott <NoOne@NoWhere.com>
Date2021-03-06 21:16 -0600
SubjectRe: Deciding the [would-not-halt] property (Undecidability == error)
Message-ID<ueSdndxQ5JT-2Nn9nZ2dnUU7-SvNnZ2d@giganews.com>
In reply to#28727
On 3/6/2021 9:00 PM, Richard Damon wrote:
> On 3/6/21 9:08 PM, olcott wrote:
>> On 3/6/2021 8:01 PM, Richard Damon wrote:
>>> On 3/6/21 8:26 PM, olcott wrote:
>>>> On 3/6/2021 7:15 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> All that I am doing at this point is proving that the original halt
>>>>>> deciding criteria defines an incorrect decision problem.
>>>>>
>>>>> That's not what you said you were doing two years ago.  Were you wrong
>>>>> back then?
>>>>
>>>> All that I am doing at this point
>>>> All that I am doing at this point
>>>> All that I am doing at this point
>>>> All that I am doing at this point
>>>>
>>>> Are you aware that this point in time is not the same point in time as
>>>> two years ago?
>>>>
>>>>> What in PO-land is an incorrect decision problem?  The halting problem
>>>>> is simply that of deciding if a computation halts or not.  There's
>>>>> nothing even remotely "incorrect" about that.
>>>>
>>>> An incorrect decision problem is simply the formal language equivalent
>>>> of the natural language incorrect question.
>>>>
>>>> Every yes/no question that cannot possibly be resolved to yes or no is
>>>> an incorrect question.
>>>>
>>>> Incorrect decision problems are typically called undecidable decision
>>>> problems. Most people never notice that the only reason that they are
>>>> undecidable is that there is something wrong with them.
>>>>
>>>> Every decision problem that cannot possibly be resolved to true or false
>>>> is an incorrect decision problem.
>>>>
>>>>
>>>
>>> Except that the question that can not be resolved is NOT the question of
>>> the Halting problem.
>>>
>>> The Halting Problem ALWAYS has a right answer.
>>
>> If there are any undecidable inputs this by itself proves that the
>> halting problem is an incorrect decision problem.
>>
>> Undecidability always means error.
>> That you fail to understand this does not make it not true.
>>
> 
> Note, the undecidable question is NOT the question of the Halting
> Problem, so that isn't the issue.
> 
> There is ALWAYS a definite answer (might not be knowable, but there is
> an answer) to the question if a given computation is finite or not.

Every undecidable instance of a decision problem is incorrect.

-- 
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre 
minds." Einstein

[toc] | [prev] | [next] | [standalone]


Page 3 of 4 — ← Prev page 1 2 [3] 4  Next page →

Back to top | Article view | comp.theory


csiph-web