Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #28415 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-03-04 08:51 -0600 |
| Last post | 2021-03-04 19:40 -0600 |
| Articles | 20 on this page of 70 — 9 participants |
Back to article view | Back to comp.theory
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 →
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Alan Mackenzie <acm@muc.de> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-05 11:02 -0600 |
| Subject | Deciding 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-05 21:02 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-05 15:15 -0600 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-05 20:42 -0500 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-06 23:43 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-06 18:00 -0600 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-06 19:33 -0500 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-07 00:38 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-06 18:53 -0600 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-03-07 01:15 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-06 19:26 -0600 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-06 21:01 -0500 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-06 20:08 -0600 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-03-06 22:00 -0500 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-03-06 21:16 -0600 |
| Subject | Re: 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