Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #39507 > unrolled thread
| Started by | olcott <NoOne@NoWhere.com> |
|---|---|
| First post | 2021-09-18 22:42 -0500 |
| Last post | 2021-09-20 19:35 -0400 |
| Articles | 20 on this page of 62 — 8 participants |
Back to article view | Back to comp.theory
Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-18 22:42 -0500
Re: Must a partial halt decider be a pure function of its inputs? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-19 02:30 -0700
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-19 06:09 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 08:15 -0400
Re: Must a partial halt decider be a pure function of its inputs? [ decidability decider ] olcott <NoOne@NoWhere.com> - 2021-09-19 10:03 -0500
Re: Must a partial halt decider be a pure function of its inputs? [ decidability decider ] Richard Damon <Richard@Damon-Family.org> - 2021-09-19 13:47 -0400
Re: Must a partial halt decider be a pure function of its inputs? [ decidability decider ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-19 23:42 +0100
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 06:39 -0400
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-19 06:25 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 08:12 -0400
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-19 09:48 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-19 13:58 -0400
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 11:20 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 19:05 +0100
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 13:16 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 19:29 +0100
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 13:40 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 19:44 +0100
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 14:04 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 20:13 +0100
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 14:27 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 20:29 +0100
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 15:08 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Mr Flibble <flibble@reddwarf.jmc> - 2021-09-19 21:32 +0100
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Richard Damon <Richard@Damon-Family.org> - 2021-09-19 19:16 -0400
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Richard Damon <Richard@Damon-Family.org> - 2021-09-19 14:05 -0400
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 13:21 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) Richard Damon <news.x.richarddamon@xoxy.net> - 2021-09-19 14:51 -0400
Re: Must a partial halt decider be a pure function of its inputs? (addendum) olcott <NoOne@NoWhere.com> - 2021-09-19 14:14 -0500
Re: Must a partial halt decider be a pure function of its inputs? (addendum) André G. Isaak <agisaak@gm.invalid> - 2021-09-19 13:41 -0600
Re: Must a partial halt decider be a pure function of its inputs? Charlie-Boo <shymathguy@gmail.com> - 2021-09-20 09:15 -0700
Re: Must a partial halt decider be a pure function of its inputs? Charlie-Boo <shymathguy@gmail.com> - 2021-09-20 09:34 -0700
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 11:46 -0500
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 11:44 -0500
Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 11:17 -0600
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 12:42 -0500
Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 11:59 -0600
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 13:59 -0500
Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 14:01 -0600
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 15:46 -0500
Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 15:07 -0600
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 16:52 -0500
Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 16:06 -0600
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 17:29 -0500
Re: Must a partial halt decider be a pure function of its inputs? André G. Isaak <agisaak@gm.invalid> - 2021-09-20 16:52 -0600
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 18:17 -0500
Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-20 23:06 +0100
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 17:37 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:31 -0400
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 18:48 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 22:38 -0400
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 21:45 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 23:27 -0400
Re: Must a partial halt decider be a pure function of its inputs? Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-09-20 23:14 -0700
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-21 09:39 -0500
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-21 19:16 -0400
Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 01:45 +0100
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 19:53 -0500
Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 02:39 +0100
Re: Must a partial halt decider be a pure function of its inputs? olcott <NoOne@NoWhere.com> - 2021-09-20 20:44 -0500
Re: Must a partial halt decider be a pure function of its inputs? Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-09-21 03:33 +0100
Re: Must a partial halt decider be a pure function of its inputs? Richard Damon <Richard@Damon-Family.org> - 2021-09-20 19:35 -0400
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-19 14:27 -0500 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <I_CdnWYzBIO0Etr8nZ2dnUU7-VGdnZ2d@giganews.com> |
| In reply to | #39551 |
On 9/19/2021 2:13 PM, Mr Flibble wrote:
> On Sun, 19 Sep 2021 14:04:41 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 9/19/2021 1:44 PM, Mr Flibble wrote:
>>> On Sun, 19 Sep 2021 13:40:36 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 9/19/2021 1:29 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Sep 2021 13:16:24 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 9/19/2021 1:05 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Sep 2021 11:20:15 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 9/18/2021 10:42 PM, olcott wrote:
>>>>>>>>> This is my paraphrase of the requirement a partial
>>>>>>>>> halt decider must be a pure function of its inputs:
>>>>>>>>>
>>>>>>>>> As long as there is one set of inputs such as such as the
>>>>>>>>> formal parameters to a function and a single output such as
>>>>>>>>> return value of {1,0} (indicating true or false) from this
>>>>>>>>> function, then whatever occurs in-between does not make any
>>>>>>>>> difference.
>>>>>>>>>
>>>>>>>>> This would mean that my use of static local variables has no
>>>>>>>>> detrimental effect on the applicability of my partial halt
>>>>>>>>> decider to the halting problem.
>>>>>>>>>
>>>>>>>>> u32 H(u32 P, u32 I)
>>>>>>>>> {
>>>>>>>>> static u32 Aborted;
>>>>>>>>> static u32* execution_trace;
>>>>>>>>
>>>>>>>> Although a "pure function" would seem to require both elements
>>>>>>>> on the link provided below, a "pure function of its inputs"
>>>>>>>> seems to only require this first element.
>>>>>>>>
>>>>>>>> (1) The function return values are identical for identical
>>>>>>>> arguments (no variation with local static variables, non-local
>>>>>>>> variables, mutable reference arguments or input streams).
>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>
>>>>>>>> This seems to be saying as long as the final return value of a
>>>>>>>> function is consistently the same for any specific initial
>>>>>>>> arguments it does not matter that:
>>>>>>>> (a) local static variables
>>>>>>>> (b) non-local variables
>>>>>>>> (c) mutable reference arguments
>>>>>>>> (d) input streams
>>>>>>>>
>>>>>>>> are used to achieve this consistent return value.
>>>>>>>
>>>>>>> No, a pure function cannot have any side effects: changing
>>>>>>> static variables is a side effect.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> It does not have to be an actual pure function, it only has to
>>>>>> be a pure function of its inputs.
>>>>>
>>>>> "a pure function of its inputs" makes no sense:
>>>>
>>>> It is merely the first element of the linked "pure function"
>>>> requirements.
>>>
>>> It is merely something that makes no sense. Pure functions CANNOT
>>> have any side effects.
>>>
>>> /Flibble
>>>
>>
>> Then a function that can always know when it has been called in
>> infinite recursion is simply not allowed. That makes no sense.
>
> Your conclusion makes no sense. What isn't allowed here is
> your use of the term "pure function" to describe something that isn't a
> pure function.
>
> /Flibble
>
This was always presented to me as "a pure function of its inputs".
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-09-19 20:29 +0100 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <20210919202944.00007ff6@reddwarf.jmc> |
| In reply to | #39555 |
On Sun, 19 Sep 2021 14:27:37 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 9/19/2021 2:13 PM, Mr Flibble wrote:
> > On Sun, 19 Sep 2021 14:04:41 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 9/19/2021 1:44 PM, Mr Flibble wrote:
> >>> On Sun, 19 Sep 2021 13:40:36 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 9/19/2021 1:29 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Sep 2021 13:16:24 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 9/19/2021 1:05 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Sep 2021 11:20:15 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 9/18/2021 10:42 PM, olcott wrote:
> >>>>>>>>> This is my paraphrase of the requirement a partial
> >>>>>>>>> halt decider must be a pure function of its inputs:
> >>>>>>>>>
> >>>>>>>>> As long as there is one set of inputs such as such as the
> >>>>>>>>> formal parameters to a function and a single output such as
> >>>>>>>>> return value of {1,0} (indicating true or false) from this
> >>>>>>>>> function, then whatever occurs in-between does not make any
> >>>>>>>>> difference.
> >>>>>>>>>
> >>>>>>>>> This would mean that my use of static local variables has no
> >>>>>>>>> detrimental effect on the applicability of my partial halt
> >>>>>>>>> decider to the halting problem.
> >>>>>>>>>
> >>>>>>>>> u32 H(u32 P, u32 I)
> >>>>>>>>> {
> >>>>>>>>> static u32 Aborted;
> >>>>>>>>> static u32* execution_trace;
> >>>>>>>>
> >>>>>>>> Although a "pure function" would seem to require both
> >>>>>>>> elements on the link provided below, a "pure function of its
> >>>>>>>> inputs" seems to only require this first element.
> >>>>>>>>
> >>>>>>>> (1) The function return values are identical for identical
> >>>>>>>> arguments (no variation with local static variables,
> >>>>>>>> non-local variables, mutable reference arguments or input
> >>>>>>>> streams). https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>
> >>>>>>>> This seems to be saying as long as the final return value of
> >>>>>>>> a function is consistently the same for any specific initial
> >>>>>>>> arguments it does not matter that:
> >>>>>>>> (a) local static variables
> >>>>>>>> (b) non-local variables
> >>>>>>>> (c) mutable reference arguments
> >>>>>>>> (d) input streams
> >>>>>>>>
> >>>>>>>> are used to achieve this consistent return value.
> >>>>>>>
> >>>>>>> No, a pure function cannot have any side effects: changing
> >>>>>>> static variables is a side effect.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> It does not have to be an actual pure function, it only has to
> >>>>>> be a pure function of its inputs.
> >>>>>
> >>>>> "a pure function of its inputs" makes no sense:
> >>>>
> >>>> It is merely the first element of the linked "pure function"
> >>>> requirements.
> >>>
> >>> It is merely something that makes no sense. Pure functions CANNOT
> >>> have any side effects.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Then a function that can always know when it has been called in
> >> infinite recursion is simply not allowed. That makes no sense.
> >
> > Your conclusion makes no sense. What isn't allowed here is
> > your use of the term "pure function" to describe something that
> > isn't a pure function.
> >
> > /Flibble
> >
>
> This was always presented to me as "a pure function of its inputs".
So what in your mind is the difference between a pure function and a
"pure function of its inputs"? If a "pure function of its inputs" has
side effects then it isn't a pure function, period.
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-19 15:08 -0500 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <uLCdnZteQYlKBdr8nZ2dnUU7-evNnZ2d@giganews.com> |
| In reply to | #39556 |
On 9/19/2021 2:29 PM, Mr Flibble wrote:
> On Sun, 19 Sep 2021 14:27:37 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 9/19/2021 2:13 PM, Mr Flibble wrote:
>>> On Sun, 19 Sep 2021 14:04:41 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 9/19/2021 1:44 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Sep 2021 13:40:36 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 9/19/2021 1:29 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Sep 2021 13:16:24 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 9/19/2021 1:05 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Sep 2021 11:20:15 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 9/18/2021 10:42 PM, olcott wrote:
>>>>>>>>>>> This is my paraphrase of the requirement a partial
>>>>>>>>>>> halt decider must be a pure function of its inputs:
>>>>>>>>>>>
>>>>>>>>>>> As long as there is one set of inputs such as such as the
>>>>>>>>>>> formal parameters to a function and a single output such as
>>>>>>>>>>> return value of {1,0} (indicating true or false) from this
>>>>>>>>>>> function, then whatever occurs in-between does not make any
>>>>>>>>>>> difference.
>>>>>>>>>>>
>>>>>>>>>>> This would mean that my use of static local variables has no
>>>>>>>>>>> detrimental effect on the applicability of my partial halt
>>>>>>>>>>> decider to the halting problem.
>>>>>>>>>>>
>>>>>>>>>>> u32 H(u32 P, u32 I)
>>>>>>>>>>> {
>>>>>>>>>>> static u32 Aborted;
>>>>>>>>>>> static u32* execution_trace;
>>>>>>>>>>
>>>>>>>>>> Although a "pure function" would seem to require both
>>>>>>>>>> elements on the link provided below, a "pure function of its
>>>>>>>>>> inputs" seems to only require this first element.
>>>>>>>>>>
>>>>>>>>>> (1) The function return values are identical for identical
>>>>>>>>>> arguments (no variation with local static variables,
>>>>>>>>>> non-local variables, mutable reference arguments or input
>>>>>>>>>> streams). https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>
>>>>>>>>>> This seems to be saying as long as the final return value of
>>>>>>>>>> a function is consistently the same for any specific initial
>>>>>>>>>> arguments it does not matter that:
>>>>>>>>>> (a) local static variables
>>>>>>>>>> (b) non-local variables
>>>>>>>>>> (c) mutable reference arguments
>>>>>>>>>> (d) input streams
>>>>>>>>>>
>>>>>>>>>> are used to achieve this consistent return value.
>>>>>>>>>
>>>>>>>>> No, a pure function cannot have any side effects: changing
>>>>>>>>> static variables is a side effect.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> It does not have to be an actual pure function, it only has to
>>>>>>>> be a pure function of its inputs.
>>>>>>>
>>>>>>> "a pure function of its inputs" makes no sense:
>>>>>>
>>>>>> It is merely the first element of the linked "pure function"
>>>>>> requirements.
>>>>>
>>>>> It is merely something that makes no sense. Pure functions CANNOT
>>>>> have any side effects.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Then a function that can always know when it has been called in
>>>> infinite recursion is simply not allowed. That makes no sense.
>>>
>>> Your conclusion makes no sense. What isn't allowed here is
>>> your use of the term "pure function" to describe something that
>>> isn't a pure function.
>>>
>>> /Flibble
>>>
>>
>> This was always presented to me as "a pure function of its inputs".
>
> So what in your mind is the difference between a pure function and a
> "pure function of its inputs"? If a "pure function of its inputs" has
> side effects then it isn't a pure function, period.
>
> /Flibble
>
Pure functions relate to functional programming in software engineering.
Pure functions of their inputs relates to computer science computations.
A pure function of its inputs bases its return value entirely on its
inputs and/or additional intermediate computations that are derived from
these inputs.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mr Flibble <flibble@reddwarf.jmc> |
|---|---|
| Date | 2021-09-19 21:32 +0100 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <20210919213225.00004429@reddwarf.jmc> |
| In reply to | #39562 |
On Sun, 19 Sep 2021 15:08:54 -0500
olcott <NoOne@NoWhere.com> wrote:
> On 9/19/2021 2:29 PM, Mr Flibble wrote:
> > On Sun, 19 Sep 2021 14:27:37 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 9/19/2021 2:13 PM, Mr Flibble wrote:
> >>> On Sun, 19 Sep 2021 14:04:41 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 9/19/2021 1:44 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Sep 2021 13:40:36 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 9/19/2021 1:29 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Sep 2021 13:16:24 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 9/19/2021 1:05 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Sep 2021 11:20:15 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 9/18/2021 10:42 PM, olcott wrote:
> >>>>>>>>>>> This is my paraphrase of the requirement a partial
> >>>>>>>>>>> halt decider must be a pure function of its inputs:
> >>>>>>>>>>>
> >>>>>>>>>>> As long as there is one set of inputs such as such as the
> >>>>>>>>>>> formal parameters to a function and a single output such
> >>>>>>>>>>> as return value of {1,0} (indicating true or false) from
> >>>>>>>>>>> this function, then whatever occurs in-between does not
> >>>>>>>>>>> make any difference.
> >>>>>>>>>>>
> >>>>>>>>>>> This would mean that my use of static local variables has
> >>>>>>>>>>> no detrimental effect on the applicability of my partial
> >>>>>>>>>>> halt decider to the halting problem.
> >>>>>>>>>>>
> >>>>>>>>>>> u32 H(u32 P, u32 I)
> >>>>>>>>>>> {
> >>>>>>>>>>> static u32 Aborted;
> >>>>>>>>>>> static u32* execution_trace;
> >>>>>>>>>>
> >>>>>>>>>> Although a "pure function" would seem to require both
> >>>>>>>>>> elements on the link provided below, a "pure function of
> >>>>>>>>>> its inputs" seems to only require this first element.
> >>>>>>>>>>
> >>>>>>>>>> (1) The function return values are identical for identical
> >>>>>>>>>> arguments (no variation with local static variables,
> >>>>>>>>>> non-local variables, mutable reference arguments or input
> >>>>>>>>>> streams). https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>
> >>>>>>>>>> This seems to be saying as long as the final return value
> >>>>>>>>>> of a function is consistently the same for any specific
> >>>>>>>>>> initial arguments it does not matter that:
> >>>>>>>>>> (a) local static variables
> >>>>>>>>>> (b) non-local variables
> >>>>>>>>>> (c) mutable reference arguments
> >>>>>>>>>> (d) input streams
> >>>>>>>>>>
> >>>>>>>>>> are used to achieve this consistent return value.
> >>>>>>>>>
> >>>>>>>>> No, a pure function cannot have any side effects: changing
> >>>>>>>>> static variables is a side effect.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> It does not have to be an actual pure function, it only has
> >>>>>>>> to be a pure function of its inputs.
> >>>>>>>
> >>>>>>> "a pure function of its inputs" makes no sense:
> >>>>>>
> >>>>>> It is merely the first element of the linked "pure function"
> >>>>>> requirements.
> >>>>>
> >>>>> It is merely something that makes no sense. Pure functions
> >>>>> CANNOT have any side effects.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Then a function that can always know when it has been called in
> >>>> infinite recursion is simply not allowed. That makes no sense.
> >>>
> >>> Your conclusion makes no sense. What isn't allowed here is
> >>> your use of the term "pure function" to describe something that
> >>> isn't a pure function.
> >>>
> >>> /Flibble
> >>>
> >>
> >> This was always presented to me as "a pure function of its
> >> inputs".
> >
> > So what in your mind is the difference between a pure function and a
> > "pure function of its inputs"? If a "pure function of its inputs"
> > has side effects then it isn't a pure function, period.
> >
> > /Flibble
> >
>
> Pure functions relate to functional programming in software
> engineering. Pure functions of their inputs relates to computer
> science computations.
>
> A pure function of its inputs bases its return value entirely on its
> inputs and/or additional intermediate computations that are derived
> from these inputs.
You failed to define any differences between a pure function and a
"pure function of its inputs".
/Flibble
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-19 19:16 -0400 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <9xP1J.40321$2Q_3.7846@fx35.iad> |
| In reply to | #39549 |
On 9/19/21 3:04 PM, olcott wrote: > > Then a function that can always know when it has been called in infinite > recursion is simply not allowed. That makes no sense. Yes, By definition the results of a Computation can't depend on if it is being evoked recursively, so you can say in effect that it can't detect the recursion. Technically, it might be able to detect it, it just can't change its answer based on it, so what good is detecting it. It makes perfect sense, 3! is 6, it doesn't matter if that 3! is being asked as simple 3! or if 4! is computing 4 * 3!, the answer is the same. Yes, there might be a function used WITHIN a computation (not as one itself) that might need to detect this sort of thing, and that is fine. It is just that if something is defined to be a mapping of its inputs to an output that is just based on those inputs, such a thing won't depend on things like is it being used recursively.
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-09-19 14:05 -0400 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <rZK1J.17245$dI3.3336@fx10.iad> |
| In reply to | #39528 |
On 9/19/21 12:20 PM, olcott wrote:
> On 9/18/2021 10:42 PM, olcott wrote:
>> This is my paraphrase of the requirement a partial
>> halt decider must be a pure function of its inputs:
>>
>> As long as there is one set of inputs such as such as the formal
>> parameters to a function and a single output such as return value of
>> {1,0} (indicating true or false) from this function, then whatever
>> occurs in-between does not make any difference.
>>
>> This would mean that my use of static local variables has no
>> detrimental effect on the applicability of my partial halt decider to
>> the halting problem.
>>
>> u32 H(u32 P, u32 I)
>> {
>> static u32 Aborted;
>> static u32* execution_trace;
>
> Although a "pure function" would seem to require both elements on the
> link provided below, a "pure function of its inputs" seems to only
> require this first element.
>
> (1) The function return values are identical for identical arguments
> (no variation with local static variables, non-local variables, mutable
> reference arguments or input streams).
> https://en.wikipedia.org/wiki/Pure_function
>
> This seems to be saying as long as the final return value of a function
> is consistently the same for any specific initial arguments it does not
> matter that:
> (a) local static variables
> (b) non-local variables
> (c) mutable reference arguments
> (d) input streams
>
> are used to achieve this consistent return value.
>
Right, those items, do not BY THEMSELVES, make the code not a
computation. They do make it much easier for it to end up being not a
computation.
Note, The rules for Computaiton theory are different than in 'Normal'
Computer Science, which tend to define a Pure Function on a more
mechanical rather than behavioral definition.
Enforcing the mechanical rules makes sure you meet the behavioral rules,
but are not absolutely required.
If you do any of that list, it can be very hard to show that you code
is, in fact, a computation.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-19 13:21 -0500 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <9v2dncLT_fQ24tr8nZ2dnUU7-X_NnZ2d@giganews.com> |
| In reply to | #39539 |
On 9/19/2021 1:05 PM, Richard Damon wrote:
> On 9/19/21 12:20 PM, olcott wrote:
>> On 9/18/2021 10:42 PM, olcott wrote:
>>> This is my paraphrase of the requirement a partial
>>> halt decider must be a pure function of its inputs:
>>>
>>> As long as there is one set of inputs such as such as the formal
>>> parameters to a function and a single output such as return value of
>>> {1,0} (indicating true or false) from this function, then whatever
>>> occurs in-between does not make any difference.
>>>
>>> This would mean that my use of static local variables has no
>>> detrimental effect on the applicability of my partial halt decider to
>>> the halting problem.
>>>
>>> u32 H(u32 P, u32 I)
>>> {
>>> static u32 Aborted;
>>> static u32* execution_trace;
>>
>> Although a "pure function" would seem to require both elements on the
>> link provided below, a "pure function of its inputs" seems to only
>> require this first element.
>>
>> (1) The function return values are identical for identical arguments
>> (no variation with local static variables, non-local variables, mutable
>> reference arguments or input streams).
>> https://en.wikipedia.org/wiki/Pure_function
>>
>> This seems to be saying as long as the final return value of a function
>> is consistently the same for any specific initial arguments it does not
>> matter that:
>> (a) local static variables
>> (b) non-local variables
>> (c) mutable reference arguments
>> (d) input streams
>>
>> are used to achieve this consistent return value.
>>
>
>
> Right, those items, do not BY THEMSELVES, make the code not a
> computation. They do make it much easier for it to end up being not a
> computation.
>
> Note, The rules for Computaiton theory are different than in 'Normal'
> Computer Science, which tend to define a Pure Function on a more
> mechanical rather than behavioral definition.
>
> Enforcing the mechanical rules makes sure you meet the behavioral rules,
> but are not absolutely required.
>
> If you do any of that list, it can be very hard to show that you code
> is, in fact, a computation.
>
Surprisingly it seems that you have the best understanding of this of
all of the reviewers that have responded to this.
void P(u32 x)
{
H(x, x);
}
int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}
Does this still meet the Halting Problem requirement that the function
must be a pure function of its inputs:
The concern is that H is called three times and only terminates its
input after it has seen enough of the execution trace to determine that
it specifies infinitely recursive simulation. The initial invocation of
H(P,P) always eventually returns 0. The intermediate simulations of
H(P,P) never return.
Can we construe this whole thing as a single computation such that the
eventual return value of the execution H(P,P) is a pure function of its
inputs?
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Richard Damon <news.x.richarddamon@xoxy.net> |
|---|---|
| Date | 2021-09-19 14:51 -0400 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <si80rd$mmo$1@dont-email.me> |
| In reply to | #39542 |
On 9/19/21 2:21 PM, olcott wrote:
> On 9/19/2021 1:05 PM, Richard Damon wrote:
>> On 9/19/21 12:20 PM, olcott wrote:
>>> On 9/18/2021 10:42 PM, olcott wrote:
>>>> This is my paraphrase of the requirement a partial
>>>> halt decider must be a pure function of its inputs:
>>>>
>>>> As long as there is one set of inputs such as such as the formal
>>>> parameters to a function and a single output such as return value of
>>>> {1,0} (indicating true or false) from this function, then whatever
>>>> occurs in-between does not make any difference.
>>>>
>>>> This would mean that my use of static local variables has no
>>>> detrimental effect on the applicability of my partial halt decider to
>>>> the halting problem.
>>>>
>>>> u32 H(u32 P, u32 I)
>>>> {
>>>> static u32 Aborted;
>>>> static u32* execution_trace;
>>>
>>> Although a "pure function" would seem to require both elements on the
>>> link provided below, a "pure function of its inputs" seems to only
>>> require this first element.
>>>
>>> (1) The function return values are identical for identical arguments
>>> (no variation with local static variables, non-local variables, mutable
>>> reference arguments or input streams).
>>> https://en.wikipedia.org/wiki/Pure_function
>>>
>>> This seems to be saying as long as the final return value of a function
>>> is consistently the same for any specific initial arguments it does not
>>> matter that:
>>> (a) local static variables
>>> (b) non-local variables
>>> (c) mutable reference arguments
>>> (d) input streams
>>>
>>> are used to achieve this consistent return value.
>>>
>>
>>
>> Right, those items, do not BY THEMSELVES, make the code not a
>> computation. They do make it much easier for it to end up being not a
>> computation.
>>
>> Note, The rules for Computaiton theory are different than in 'Normal'
>> Computer Science, which tend to define a Pure Function on a more
>> mechanical rather than behavioral definition.
>>
>> Enforcing the mechanical rules makes sure you meet the behavioral rules,
>> but are not absolutely required.
>>
>> If you do any of that list, it can be very hard to show that you code
>> is, in fact, a computation.
>>
>
> Surprisingly it seems that you have the best understanding of this of
> all of the reviewers that have responded to this.
>
>
>
> void P(u32 x)
> {
> H(x, x);
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)P, (u32)P));
> }
>
> Does this still meet the Halting Problem requirement that the function
> must be a pure function of its inputs:
>
> The concern is that H is called three times and only terminates its
> input after it has seen enough of the execution trace to determine that
> it specifies infinitely recursive simulation. The initial invocation of
> H(P,P) always eventually returns 0. The intermediate simulations of
> H(P,P) never return.
>
> Can we construe this whole thing as a single computation such that the
> eventual return value of the execution H(P,P) is a pure function of its
> inputs?
>
>
The problem is that whatever you are going to call your decider that
needs to be this pure function MUST be allowed to be used in various
contexts and must stay consistent.
For instance, lets look at your H.
We have the call to H inside the top level instance of P. P(P) calls
H(P,P) and this returns Non-Halting as aggreed (I think) by everyone.
We then have the call H as a top level function, like in your main
above, and there again, we have the call to H(P,P) and it returns
non-halting.
This is consistent to the previous instance, but would seem to be the
wrong answer (since P(P) Halted), but your claim is that it is right
because the SIMULATED P(P) never halted. But for the simulted P(P) to
not halt, then we see the simulated P calls a Simulated H(P,P) and for P
to never halt, the H(P,P) must not return.
This means that either this simulation itself is defective (which puts
your whole proof into shambles) or it demonstrates that H(P,P) doesn't
always behave the same way, and thus H is not a computation. This also
makes your whole proof irrelevant, as if H isn't actually a computation,
then it isn't possibly a decider.
You CAN'T just try to define that everything is a single computation, as
the problem physically has at least two computations in view: P(I) and
H(P,I) and for the H^ case, P(I) envokes the same computation at H(P,I)
and these must agree, AND the answer given by H(P,I) must agrees with
the behavior of P(I). Your whole proof seems to be trying to justify the
answer from H(P,I) not matching the behavior of P(I) but that whole
arguement seems to rest on the copy of H inside the simulated P not
doing exactly the same thing as the outer H.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-19 14:14 -0500 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <yr6dnf_W9oqbEdr8nZ2dnUU7-TfNnZ2d@giganews.com> |
| In reply to | #39548 |
On 9/19/2021 1:51 PM, Richard Damon wrote:
>
> On 9/19/21 2:21 PM, olcott wrote:
>> On 9/19/2021 1:05 PM, Richard Damon wrote:
>>> On 9/19/21 12:20 PM, olcott wrote:
>>>> On 9/18/2021 10:42 PM, olcott wrote:
>>>>> This is my paraphrase of the requirement a partial
>>>>> halt decider must be a pure function of its inputs:
>>>>>
>>>>> As long as there is one set of inputs such as such as the formal
>>>>> parameters to a function and a single output such as return value of
>>>>> {1,0} (indicating true or false) from this function, then whatever
>>>>> occurs in-between does not make any difference.
>>>>>
>>>>> This would mean that my use of static local variables has no
>>>>> detrimental effect on the applicability of my partial halt decider to
>>>>> the halting problem.
>>>>>
>>>>> u32 H(u32 P, u32 I)
>>>>> {
>>>>> static u32 Aborted;
>>>>> static u32* execution_trace;
>>>>
>>>> Although a "pure function" would seem to require both elements on the
>>>> link provided below, a "pure function of its inputs" seems to only
>>>> require this first element.
>>>>
>>>> (1) The function return values are identical for identical arguments
>>>> (no variation with local static variables, non-local variables, mutable
>>>> reference arguments or input streams).
>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>
>>>> This seems to be saying as long as the final return value of a function
>>>> is consistently the same for any specific initial arguments it does not
>>>> matter that:
>>>> (a) local static variables
>>>> (b) non-local variables
>>>> (c) mutable reference arguments
>>>> (d) input streams
>>>>
>>>> are used to achieve this consistent return value.
>>>>
>>>
>>>
>>> Right, those items, do not BY THEMSELVES, make the code not a
>>> computation. They do make it much easier for it to end up being not a
>>> computation.
>>>
>>> Note, The rules for Computaiton theory are different than in 'Normal'
>>> Computer Science, which tend to define a Pure Function on a more
>>> mechanical rather than behavioral definition.
>>>
>>> Enforcing the mechanical rules makes sure you meet the behavioral rules,
>>> but are not absolutely required.
>>>
>>> If you do any of that list, it can be very hard to show that you code
>>> is, in fact, a computation.
>>>
>>
>> Surprisingly it seems that you have the best understanding of this of
>> all of the reviewers that have responded to this.
>>
>>
>>
>> void P(u32 x)
>> {
>> H(x, x);
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> Does this still meet the Halting Problem requirement that the function
>> must be a pure function of its inputs:
>>
>> The concern is that H is called three times and only terminates its
>> input after it has seen enough of the execution trace to determine that
>> it specifies infinitely recursive simulation. The initial invocation of
>> H(P,P) always eventually returns 0. The intermediate simulations of
>> H(P,P) never return.
>>
>> Can we construe this whole thing as a single computation such that the
>> eventual return value of the execution H(P,P) is a pure function of its
>> inputs?
>>
>>
>
> The problem is that whatever you are going to call your decider that
> needs to be this pure function MUST be allowed to be used in various
> contexts and must stay consistent.
>
> For instance, lets look at your H.
>
> We have the call to H inside the top level instance of P. P(P) calls
> H(P,P) and this returns Non-Halting as aggreed (I think) by everyone.
>
> We then have the call H as a top level function, like in your main
> above, and there again, we have the call to H(P,P) and it returns
> non-halting.
>
> This is consistent to the previous instance, but would seem to be the
> wrong answer (since P(P) Halted), but your claim is that it is right
> because the SIMULATED P(P) never halted. But for the simulted P(P) to
> not halt, then we see the simulated P calls a Simulated H(P,P) and for P
> to never halt, the H(P,P) must not return.
>
The problem is that the input is semantically erroneous.
If "This sentence is not true" was a valid truth bearer
then the fact that it is not true would make it false.
Because this forms a contradiction that means it is not
a valid truth bearer.
Although it can be easily verified that the input to H(P,P)
must have its simulation aborted to prevent its infinite
execution thus proving this this input never halts, as soon
as soon as we use this correct never halting status to
abort the simulation then P(P) halts. It does this because
H(P,P) has self-contradictory input.
This correctly decides that some TM/input pairs are self-contradictory.
u32 PSR_Olcott_2004(u32 P)
{
return H1(P,P) != H(P,P);
}
> This means that either this simulation itself is defective (which puts
> your whole proof into shambles) or it demonstrates that H(P,P) doesn't
> always behave the same way, and thus H is not a computation. This also
> makes your whole proof irrelevant, as if H isn't actually a computation,
> then it isn't possibly a decider.
>
> You CAN'T just try to define that everything is a single computation, as
> the problem physically has at least two computations in view: P(I) and
> H(P,I) and for the H^ case, P(I) envokes the same computation at H(P,I)
> and these must agree, AND the answer given by H(P,I) must agrees with
> the behavior of P(I). Your whole proof seems to be trying to justify the
> answer from H(P,I) not matching the behavior of P(I) but that whole
> arguement seems to rest on the copy of H inside the simulated P not
> doing exactly the same thing as the outer H.
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-19 13:41 -0600 |
| Subject | Re: Must a partial halt decider be a pure function of its inputs? (addendum) |
| Message-ID | <si83pl$k1q$1@dont-email.me> |
| In reply to | #39552 |
On 2021-09-19 13:14, olcott wrote: >> This is consistent to the previous instance, but would seem to be the >> wrong answer (since P(P) Halted), but your claim is that it is right >> because the SIMULATED P(P) never halted. But for the simulted P(P) to >> not halt, then we see the simulated P calls a Simulated H(P,P) and for P >> to never halt, the H(P,P) must not return. >> > > The problem is that the input is semantically erroneous. How can P(P) possibly be 'semantically erroneous'? What 'semantic' principle does it violate? It is a function with perfectly well-defined halting behaviour. Assuming your C code compiles and your compiler isn't garbage, presumably it behaves in accordance with the semantics of the C language. So where is the semantic error? André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | Charlie-Boo <shymathguy@gmail.com> |
|---|---|
| Date | 2021-09-20 09:15 -0700 |
| Message-ID | <66e383e8-891f-4f49-b77a-492743c7eba0n@googlegroups.com> |
| In reply to | #39507 |
On Saturday, September 18, 2021 at 11:42:41 PM UTC-4, olcott wrote:
> This is my paraphrase of the requirement a partial
> halt decider must be a pure function of its inputs:
>
> As long as there is one set of inputs such as such as the formal
> parameters to a function and a single output such as return value of
> {1,0} (indicating true or false) from this function, then whatever
> occurs in-between does not make any difference.
>
> This would mean that my use of static local variables has no detrimental
> effect on the applicability of my partial halt decider to the halting
> problem.
>
> u32 H(u32 P, u32 I)
> {
> static u32 Aborted;
> static u32* execution_trace;
>
>
>
> --
> Copyright 2021 Pete Olcott
>
> "Great spirits have always encountered violent opposition from mediocre
> minds." Einstein
There is no significance to solving "some instances" of a problem. That includes no instances or trivial instances (here it would be YES answers) which have no significance.
It's basically impossible to carve out any non-trivial subsets of programs whose halting problem can be solved.
The easiest way to advance unsolvable problems (nonrecursive sets) has always been to find unsolved problems - proving sets are not recursive, typically r.e. sets.
C-B
[toc] | [prev] | [next] | [standalone]
| From | Charlie-Boo <shymathguy@gmail.com> |
|---|---|
| Date | 2021-09-20 09:34 -0700 |
| Message-ID | <e8d8ecd3-f5e1-48b9-9ef4-86f2904f11c6n@googlegroups.com> |
| In reply to | #39607 |
BTW Turing is the Great Spirit and you are the other guy. > > "Great spirits have always encountered violent opposition from mediocre > > minds." Einstein > There is no significance to solving "some instances" of a problem. That includes no instances or trivial instances (here it would be YES answers) which have no significance. > It's basically impossible to carve out any non-trivial subsets of programs whose halting problem can be solved. > The easiest way to advance unsolvable problems (nonrecursive sets) has always been to find unsolved problems - proving sets are not recursive, typically r.e. sets. > C-B
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-20 11:46 -0500 |
| Message-ID | <I5adna-kQJFqJ9X8nZ2dnUU7-I2dnZ2d@giganews.com> |
| In reply to | #39608 |
On 9/20/2021 11:34 AM, Charlie-Boo wrote: > > BTW Turing is the Great Spirit and you are the other guy. > Turing is essentially the inventor of computer science and in that sense he is very great. The halting problem is merely modeled after the incompleteness theorem. >>> "Great spirits have always encountered violent opposition from mediocre >>> minds." Einstein >> There is no significance to solving "some instances" of a problem. That includes no instances or trivial instances (here it would be YES answers) which have no significance. >> It's basically impossible to carve out any non-trivial subsets of programs whose halting problem can be solved. >> The easiest way to advance unsolvable problems (nonrecursive sets) has always been to find unsolved problems - proving sets are not recursive, typically r.e. sets. >> C-B -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-20 11:44 -0500 |
| Message-ID | <I5adnaykQJHvJ9X8nZ2dnUU7-I3NnZ2d@giganews.com> |
| In reply to | #39607 |
On 9/20/2021 11:15 AM, Charlie-Boo wrote:
> On Saturday, September 18, 2021 at 11:42:41 PM UTC-4, olcott wrote:
>> This is my paraphrase of the requirement a partial
>> halt decider must be a pure function of its inputs:
>>
>> As long as there is one set of inputs such as such as the formal
>> parameters to a function and a single output such as return value of
>> {1,0} (indicating true or false) from this function, then whatever
>> occurs in-between does not make any difference.
>>
>> This would mean that my use of static local variables has no detrimental
>> effect on the applicability of my partial halt decider to the halting
>> problem.
>>
>> u32 H(u32 P, u32 I)
>> {
>> static u32 Aborted;
>> static u32* execution_trace;
>>
>>
>>
>> --
>> Copyright 2021 Pete Olcott
>>
>> "Great spirits have always encountered violent opposition from mediocre
>> minds." Einstein
> There is no significance to solving "some instances" of a problem. That includes no instances or trivial instances (here it would be YES answers) which have no significance.
> It's basically impossible to carve out any non-trivial subsets of programs whose halting problem can be solved.
> The easiest way to advance unsolvable problems (nonrecursive sets) has always been to find unsolved problems - proving sets are not recursive, typically r.e. sets.
> C-B
>
void P(u32 x)
{
if (H(x, x))
HERE: goto HERE;
}
int main()
{
Output("Input_Halts = ", H1((u32)P, (u32)P));
}
H and H1 are simulating partial halt deciders that make their halt
status decision on the basis of whether or not the execution trace of
the simulation of their input matches one of two known infinite
execution patterns.
The above conventional undecidable TM/input pair is correctly decided as
halting on the basis of fully operational C/x86 code in the x86utm
operating system.
H1 is an exact copy of H and is able to correctly decide that its input
halts because P was not designed to contradict H1. Because P was
intentionally designed to contradict H the return value from H and H1
are not the same.
The key question of this post is whether H/H1 would be disallowed as
Turing computable on the basis that H must use static local variables to
keep track of the execution trace of its input across subsequent
recursive simulations. If it used non-static locals the stored execution
trace of H would keep getting erased on every recursive simulation.
Since H1 is only called once this is not an issue for H1.
The initial input to H1/H and the final output from H1/H are always the
same for the same initial inputs.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-20 11:17 -0600 |
| Message-ID | <siafn0$frs$1@dont-email.me> |
| In reply to | #39610 |
On 2021-09-20 10:44, olcott wrote:
> On 9/20/2021 11:15 AM, Charlie-Boo wrote:
>> On Saturday, September 18, 2021 at 11:42:41 PM UTC-4, olcott wrote:
>>> This is my paraphrase of the requirement a partial
>>> halt decider must be a pure function of its inputs:
>>>
>>> As long as there is one set of inputs such as such as the formal
>>> parameters to a function and a single output such as return value of
>>> {1,0} (indicating true or false) from this function, then whatever
>>> occurs in-between does not make any difference.
>>>
>>> This would mean that my use of static local variables has no detrimental
>>> effect on the applicability of my partial halt decider to the halting
>>> problem.
>>>
>>> u32 H(u32 P, u32 I)
>>> {
>>> static u32 Aborted;
>>> static u32* execution_trace;
>>>
>>>
>>>
>>> --
>>> Copyright 2021 Pete Olcott
>>>
>>> "Great spirits have always encountered violent opposition from mediocre
>>> minds." Einstein
>
>> There is no significance to solving "some instances" of a problem.
>> That includes no instances or trivial instances (here it would be YES
>> answers) which have no significance.
>> It's basically impossible to carve out any non-trivial subsets of
>> programs whose halting problem can be solved.
>> The easiest way to advance unsolvable problems (nonrecursive sets) has
>> always been to find unsolved problems - proving sets are not
>> recursive, typically r.e. sets.
>> C-B
>>
>
> void P(u32 x)
> {
> if (H(x, x))
> HERE: goto HERE;
> }
>
> int main()
> {
> Output("Input_Halts = ", H1((u32)P, (u32)P));
> }
>
> H and H1 are simulating partial halt deciders that make their halt
> status decision on the basis of whether or not the execution trace of
> the simulation of their input matches one of two known infinite
> execution patterns.
>
> The above conventional undecidable TM/input pair is correctly decided as
> halting on the basis of fully operational C/x86 code in the x86utm
> operating system.
Your P is derived from H (somewhat) in accordance with the rules that
Linz uses to derive H_Hat from H.
Your P is *not* derived from H1 in this way.
If your H1 can correctly decide (P, P) that has no bearing on Linz. Linz
never claimed that you cannot construct a TM which correctly decides
H_Hat, H_Hat. He claims only that H cannot do so.
Your H can *not* correctly decide (P, P) and that's the case that
actually matters.
> H1 is an exact copy of H and is able to correctly decide that its input
> halts because P was not designed to contradict H1. Because P was
> intentionally designed to contradict H the return value from H and H1
> are not the same.
>
> The key question of this post is whether H/H1 would be disallowed as
> Turing computable on the basis that H must use static local variables to
> keep track of the execution trace of its input across subsequent
> recursive simulations.
If it must keep track of *any* data across different calls then it is
not a computation. So yes, it is disqualified.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-20 12:42 -0500 |
| Message-ID | <_ZidnW6GHYBiWtX8nZ2dnUU7-a_NnZ2d@giganews.com> |
| In reply to | #39615 |
On 9/20/2021 12:17 PM, André G. Isaak wrote:
> On 2021-09-20 10:44, olcott wrote:
>> On 9/20/2021 11:15 AM, Charlie-Boo wrote:
>>> On Saturday, September 18, 2021 at 11:42:41 PM UTC-4, olcott wrote:
>>>> This is my paraphrase of the requirement a partial
>>>> halt decider must be a pure function of its inputs:
>>>>
>>>> As long as there is one set of inputs such as such as the formal
>>>> parameters to a function and a single output such as return value of
>>>> {1,0} (indicating true or false) from this function, then whatever
>>>> occurs in-between does not make any difference.
>>>>
>>>> This would mean that my use of static local variables has no
>>>> detrimental
>>>> effect on the applicability of my partial halt decider to the halting
>>>> problem.
>>>>
>>>> u32 H(u32 P, u32 I)
>>>> {
>>>> static u32 Aborted;
>>>> static u32* execution_trace;
>>>>
>>>>
>>>>
>>>> --
>>>> Copyright 2021 Pete Olcott
>>>>
>>>> "Great spirits have always encountered violent opposition from mediocre
>>>> minds." Einstein
>>
>>> There is no significance to solving "some instances" of a problem.
>>> That includes no instances or trivial instances (here it would be YES
>>> answers) which have no significance.
>>> It's basically impossible to carve out any non-trivial subsets of
>>> programs whose halting problem can be solved.
>>> The easiest way to advance unsolvable problems (nonrecursive sets)
>>> has always been to find unsolved problems - proving sets are not
>>> recursive, typically r.e. sets.
>>> C-B
>>>
>>
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>> }
>>
>> H and H1 are simulating partial halt deciders that make their halt
>> status decision on the basis of whether or not the execution trace of
>> the simulation of their input matches one of two known infinite
>> execution patterns.
>>
>> The above conventional undecidable TM/input pair is correctly decided
>> as halting on the basis of fully operational C/x86 code in the x86utm
>> operating system.
>
> Your P is derived from H (somewhat) in accordance with the rules that
> Linz uses to derive H_Hat from H.
>
> Your P is *not* derived from H1 in this way.
>
> If your H1 can correctly decide (P, P) that has no bearing on Linz.
It may seem that way to a reviewer that says blah, blah, blah, I know
that you must be wrong because I really, really believe that you must be
wrong so there is no sense in paying any attention to what you say.
On the other hand Olcott H1/H/P is analogous to Linz H/Ĥ/⟨Ĥ⟩ in that it
shows that simulating halt decider Linz H correctly decides the halt
status of the Linz input ⟨Ĥ⟩ ⟨Ĥ⟩.
> Linz
> never claimed that you cannot construct a TM which correctly decides
> H_Hat, H_Hat. He claims only that H cannot do so.
>
The whole point of the halting theorem is to prove that no universal
halt decider can possibly exist.
I have shown how to create a decidability decider that correctly decides
that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable by Ĥ.qx, thus allowing H to
be automatically selected as the correct halting decider for ⟨Ĥ⟩ ⟨Ĥ⟩,
thus the combination of the decidability decider and three instances of
the same algorithm derives a universal halt decider.
When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx, one more
instance of this same algorithm excludes the odd-man-out and thus
selects the correct halt decider.
> Your H can *not* correctly decide (P, P) and that's the case that
> actually matters.
>
>> H1 is an exact copy of H and is able to correctly decide that its
>> input halts because P was not designed to contradict H1. Because P was
>> intentionally designed to contradict H the return value from H and H1
>> are not the same.
>>
>> The key question of this post is whether H/H1 would be disallowed as
>> Turing computable on the basis that H must use static local variables
>> to keep track of the execution trace of its input across subsequent
>> recursive simulations.
>
> If it must keep track of *any* data across different calls then it is
> not a computation. So yes, it is disqualified.
>
> André
>
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-20 11:59 -0600 |
| Message-ID | <siai70$30q$1@dont-email.me> |
| In reply to | #39616 |
On 2021-09-20 11:42, olcott wrote:
> On 9/20/2021 12:17 PM, André G. Isaak wrote:
>> On 2021-09-20 10:44, olcott wrote:
>>> On 9/20/2021 11:15 AM, Charlie-Boo wrote:
>>>> On Saturday, September 18, 2021 at 11:42:41 PM UTC-4, olcott wrote:
>>>>> This is my paraphrase of the requirement a partial
>>>>> halt decider must be a pure function of its inputs:
>>>>>
>>>>> As long as there is one set of inputs such as such as the formal
>>>>> parameters to a function and a single output such as return value of
>>>>> {1,0} (indicating true or false) from this function, then whatever
>>>>> occurs in-between does not make any difference.
>>>>>
>>>>> This would mean that my use of static local variables has no
>>>>> detrimental
>>>>> effect on the applicability of my partial halt decider to the halting
>>>>> problem.
>>>>>
>>>>> u32 H(u32 P, u32 I)
>>>>> {
>>>>> static u32 Aborted;
>>>>> static u32* execution_trace;
>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> Copyright 2021 Pete Olcott
>>>>>
>>>>> "Great spirits have always encountered violent opposition from
>>>>> mediocre
>>>>> minds." Einstein
>>>
>>>> There is no significance to solving "some instances" of a problem.
>>>> That includes no instances or trivial instances (here it would be
>>>> YES answers) which have no significance.
>>>> It's basically impossible to carve out any non-trivial subsets of
>>>> programs whose halting problem can be solved.
>>>> The easiest way to advance unsolvable problems (nonrecursive sets)
>>>> has always been to find unsolved problems - proving sets are not
>>>> recursive, typically r.e. sets.
>>>> C-B
>>>>
>>>
>>> void P(u32 x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>>> }
>>>
>>> H and H1 are simulating partial halt deciders that make their halt
>>> status decision on the basis of whether or not the execution trace of
>>> the simulation of their input matches one of two known infinite
>>> execution patterns.
>>>
>>> The above conventional undecidable TM/input pair is correctly decided
>>> as halting on the basis of fully operational C/x86 code in the x86utm
>>> operating system.
>>
>> Your P is derived from H (somewhat) in accordance with the rules that
>> Linz uses to derive H_Hat from H.
>>
>> Your P is *not* derived from H1 in this way.
>>
>> If your H1 can correctly decide (P, P) that has no bearing on Linz.
>
> It may seem that way to a reviewer that says blah, blah, blah, I know
> that you must be wrong because I really, really believe that you must be
> wrong so there is no sense in paying any attention to what you say.
It doesn't merely seem that way, it is that way.
> On the other hand Olcott H1/H/P is analogous to Linz H/Ĥ/⟨Ĥ⟩ in that it
Given that your P is essentially Linz's H_Hat, How can H1/H/P be
analogous to H/Ĥ/⟨Ĥ⟩?
You're claiming that your H is somehow analogous to both Linz's H and to
Linz's H_Hat.
> shows that simulating halt decider Linz H correctly decides the halt
> status of the Linz input ⟨Ĥ⟩ ⟨Ĥ⟩.
>> Linz never claimed that you cannot construct a TM which correctly
>> decides H_Hat, H_Hat. He claims only that H cannot do so.
>>
>
> The whole point of the halting theorem is to prove that no universal
> halt decider can possibly exist.
>
> I have shown how to create a decidability decider that correctly decides
> that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable by Ĥ.qx, thus allowing H to
> be automatically selected as the correct halting decider for ⟨Ĥ⟩ ⟨Ĥ⟩,
> thus the combination of the decidability decider and three instances of
> the same algorithm derives a universal halt decider.
>
> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx, one more
> instance of this same algorithm excludes the odd-man-out and thus
> selects the correct halt decider.
But, as I have pointed out previously, and which you ignored, you are
then claiming that your *real* halt decider is the combination of H, H1,
Hx and your 'decidability decider'.
In that case your P must be derived from that *combination* if you want
to claim that it is analogous to Linz's H_Hat.
The whole point of the Linz proof is that for *any* 'halt decider' X,
one can always construct an X_Hat which it cannot decide correctly. Your
combined H+H1+Hx+DD is just as susceptible to this as any other putative
'halt decider'.
André
--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-20 13:59 -0500 |
| Message-ID | <A4CdnTwZ49dkRNX8nZ2dnUU7-SHNnZ2d@giganews.com> |
| In reply to | #39617 |
On 9/20/2021 12:59 PM, André G. Isaak wrote:
> On 2021-09-20 11:42, olcott wrote:
>> On 9/20/2021 12:17 PM, André G. Isaak wrote:
>>> On 2021-09-20 10:44, olcott wrote:
>>>> On 9/20/2021 11:15 AM, Charlie-Boo wrote:
>>>>> On Saturday, September 18, 2021 at 11:42:41 PM UTC-4, olcott wrote:
>>>>>> This is my paraphrase of the requirement a partial
>>>>>> halt decider must be a pure function of its inputs:
>>>>>>
>>>>>> As long as there is one set of inputs such as such as the formal
>>>>>> parameters to a function and a single output such as return value of
>>>>>> {1,0} (indicating true or false) from this function, then whatever
>>>>>> occurs in-between does not make any difference.
>>>>>>
>>>>>> This would mean that my use of static local variables has no
>>>>>> detrimental
>>>>>> effect on the applicability of my partial halt decider to the halting
>>>>>> problem.
>>>>>>
>>>>>> u32 H(u32 P, u32 I)
>>>>>> {
>>>>>> static u32 Aborted;
>>>>>> static u32* execution_trace;
>>>>>>
>>>>>>
>>>>>>
>>>>>> --
>>>>>> Copyright 2021 Pete Olcott
>>>>>>
>>>>>> "Great spirits have always encountered violent opposition from
>>>>>> mediocre
>>>>>> minds." Einstein
>>>>
>>>>> There is no significance to solving "some instances" of a problem.
>>>>> That includes no instances or trivial instances (here it would be
>>>>> YES answers) which have no significance.
>>>>> It's basically impossible to carve out any non-trivial subsets of
>>>>> programs whose halting problem can be solved.
>>>>> The easiest way to advance unsolvable problems (nonrecursive sets)
>>>>> has always been to find unsolved problems - proving sets are not
>>>>> recursive, typically r.e. sets.
>>>>> C-B
>>>>>
>>>>
>>>> void P(u32 x)
>>>> {
>>>> if (H(x, x))
>>>> HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H1((u32)P, (u32)P));
>>>> }
>>>>
>>>> H and H1 are simulating partial halt deciders that make their halt
>>>> status decision on the basis of whether or not the execution trace
>>>> of the simulation of their input matches one of two known infinite
>>>> execution patterns.
>>>>
>>>> The above conventional undecidable TM/input pair is correctly
>>>> decided as halting on the basis of fully operational C/x86 code in
>>>> the x86utm operating system.
>>>
>>> Your P is derived from H (somewhat) in accordance with the rules that
>>> Linz uses to derive H_Hat from H.
>>>
>>> Your P is *not* derived from H1 in this way.
>>>
>>> If your H1 can correctly decide (P, P) that has no bearing on Linz.
>>
>> It may seem that way to a reviewer that says blah, blah, blah, I know
>> that you must be wrong because I really, really believe that you must
>> be wrong so there is no sense in paying any attention to what you say.
>
> It doesn't merely seem that way, it is that way.
>
>> On the other hand Olcott H1/H/P is analogous to Linz H/Ĥ/⟨Ĥ⟩ in that it
>
> Given that your P is essentially Linz's H_Hat, How can H1/H/P be
> analogous to H/Ĥ/⟨Ĥ⟩?
>
> You're claiming that your H is somehow analogous to both Linz's H and to
> Linz's H_Hat.
>
You have to pay complete attention not merely glance at a couple of
words before forming your rebuttal.
Olcott H(P,P) is analogous to Linz Linz Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩
Olcott H1(P,P) is analogous to Linz Linz H ⟨Ĥ⟩ ⟨Ĥ⟩
>> shows that simulating halt decider Linz H correctly decides the halt
>> status of the Linz input ⟨Ĥ⟩ ⟨Ĥ⟩.
>
>>> Linz never claimed that you cannot construct a TM which correctly
>>> decides H_Hat, H_Hat. He claims only that H cannot do so.
>>>
>>
>> The whole point of the halting theorem is to prove that no universal
>> halt decider can possibly exist.
>>
>> I have shown how to create a decidability decider that correctly
>> decides that Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable by Ĥ.qx, thus
>> allowing H to be automatically selected as the correct halting decider
>> for ⟨Ĥ⟩ ⟨Ĥ⟩, thus the combination of the decidability decider and
>> three instances of the same algorithm derives a universal halt decider.
>>
>> When H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ != When Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ we know that
>> ⟨Ĥ⟩ ⟨Ĥ⟩ is not correctly decidable for either H or Ĥ.qx, one more
>> instance of this same algorithm excludes the odd-man-out and thus
>> selects the correct halt decider.
>
> But, as I have pointed out previously, and which you ignored, you are
> then claiming that your *real* halt decider is the combination of H, H1,
> Hx and your 'decidability decider'.
>
Yes.
> In that case your P must be derived from that *combination* if you want
> to claim that it is analogous to Linz's H_Hat.
>
No Olcott H1,H,Hx is superior to anything that Linz said because there
is no input that it cannot decide.
> The whole point of the Linz proof is that for *any* 'halt decider' X,
> one can always construct an X_Hat which it cannot decide correctly. Your
> combined H+H1+Hx+DD is just as susceptible to this as any other putative
> 'halt decider'.
>
> André
>
The whole point of all these proofs is that no universal halt decider
exists. The Olcott combination of H1,H,Hx is such a universal halt
decider that is purported to not exist.
The key breakthrough is that Rice's theorem "proved" that no
decidability decider can possibly exist thus once we have such a
decidability decider Rice's theorem and the halting theorem both fail.
--
Copyright 2021 Pete Olcott
"Great spirits have always encountered violent opposition from mediocre
minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-09-20 14:01 -0600 |
| Message-ID | <siapa2$k39$1@dont-email.me> |
| In reply to | #39619 |
On 2021-09-20 12:59, olcott wrote: > On 9/20/2021 12:59 PM, André G. Isaak wrote: >> But, as I have pointed out previously, and which you ignored, you are >> then claiming that your *real* halt decider is the combination of H, >> H1, Hx and your 'decidability decider'. >> > > Yes. > >> In that case your P must be derived from that *combination* if you >> want to claim that it is analogous to Linz's H_Hat. >> > > No Olcott H1,H,Hx is superior to anything that Linz said because there > is no input that it cannot decide. So show us the actual code for this new routine. I know you are never going to reveal the code for your H, but you can at least show the code for this combination routine which calls H, H1 and Hx and returns true for halting and false for non-halting. Then show the code for the hat construction derived from this new decider and show how this decider can correctly decide that hat construction. >> The whole point of the Linz proof is that for *any* 'halt decider' X, >> one can always construct an X_Hat which it cannot decide correctly. >> Your combined H+H1+Hx+DD is just as susceptible to this as any other >> putative 'halt decider'. >> >> André >> > > The whole point of all these proofs is that no universal halt decider > exists. The Olcott combination of H1,H,Hx is such a universal halt > decider that is purported to not exist. > > The key breakthrough is that Rice's theorem "proved" that no > decidability decider can possibly exist thus once we have such a > decidability decider Rice's theorem and the halting theorem both fail. You don't seem to understand what Rice's theorem actually states. André -- To email remove 'invalid' & replace 'gm' with well known Google mail service.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-09-20 15:46 -0500 |
| Message-ID | <somdnStr_seybtX8nZ2dnUU7-XHNnZ2d@giganews.com> |
| In reply to | #39620 |
On 9/20/2021 3:01 PM, André G. Isaak wrote: > On 2021-09-20 12:59, olcott wrote: >> On 9/20/2021 12:59 PM, André G. Isaak wrote: > >>> But, as I have pointed out previously, and which you ignored, you are >>> then claiming that your *real* halt decider is the combination of H, >>> H1, Hx and your 'decidability decider'. >>> >> >> Yes. >> >>> In that case your P must be derived from that *combination* if you >>> want to claim that it is analogous to Linz's H_Hat. >>> >> >> No Olcott H1,H,Hx is superior to anything that Linz said because there >> is no input that it cannot decide. > > So show us the actual code for this new routine. I know you are never > going to reveal the code for your H, but you can at least show the code > for this combination routine which calls H, H1 and Hx and returns true > for halting and false for non-halting. > > Then show the code for the hat construction derived from this new > decider and show how this decider can correctly decide that hat > construction. > Before I show any code I have to have my use of static local data validated as acceptable. >>> The whole point of the Linz proof is that for *any* 'halt decider' X, >>> one can always construct an X_Hat which it cannot decide correctly. >>> Your combined H+H1+Hx+DD is just as susceptible to this as any other >>> putative 'halt decider'. >>> >>> André >>> >> >> The whole point of all these proofs is that no universal halt decider >> exists. The Olcott combination of H1,H,Hx is such a universal halt >> decider that is purported to not exist. >> >> The key breakthrough is that Rice's theorem "proved" that no >> decidability decider can possibly exist thus once we have such a >> decidability decider Rice's theorem and the halting theorem both fail. > > You don't seem to understand what Rice's theorem actually states. > > André > Historically on comp.theory this has meant that it is impossible to create a TM the rejects undecidable inputs. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
Back to top | Article view | comp.theory
csiph-web