Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #33180 > unrolled thread
| Started by | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| First post | 2021-05-09 20:01 +0100 |
| Last post | 2021-06-27 22:19 -0700 |
| Articles | 20 on this page of 87 — 12 participants |
Back to article view | Back to comp.theory
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 20:01 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 14:11 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:03 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:11 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:33 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:39 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-05-09 13:43 -0700
Re: Halting problem undecidability and infinite recursion (PDF attached) Siri Cruise <chine.bleu@yahoo.com> - 2021-05-09 13:45 -0700
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:54 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:56 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 16:00 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 17:40 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached) Siri Cruise <chine.bleu@yahoo.com> - 2021-05-09 14:00 -0700
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 16:04 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 17:42 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-09 23:32 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 17:57 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 19:10 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( impossibly incorrect ) olcott <NoOne@NoWhere.com> - 2021-05-09 18:38 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( impossibly incorrect ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:07 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 00:25 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:37 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 18:51 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:50 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 20:33 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 21:43 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 21:06 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 22:36 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 22:31 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 23:41 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 08:17 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:32 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 19:46 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 01:43 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 22:57 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:51 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 01:09 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:24 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 01:47 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:53 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:00 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:00 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:30 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:42 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:58 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:11 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 18:49 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:45 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 20:36 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 21:51 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:03 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 05:41 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:06 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 19:47 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:02 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 02:31 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:43 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:08 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 05:32 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:05 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 16:33 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 11:49 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 16:58 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 12:09 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 11:54 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:21 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 17:00 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 11:22 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 23:59 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 18:05 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Jeff Barnett <jbb@notatt.com> - 2021-05-10 17:33 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 02:03 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 02:28 +0100
Re: Halting problem undecidability and infinite recursion (PO=Deluded Dumbo) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 04:03 +0100
Re: Halting problem undecidability and infinite recursion [ necessarily(P) ] olcott <NoOne@NoWhere.com> - 2021-05-09 22:25 -0500
Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 16:18 +0100
Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 10:25 -0500
Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 17:27 +0100
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 11:37 -0500
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 00:16 +0100
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 18:57 -0500
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 02:17 +0100
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Richard Damon <Richard@Damon-Family.org> - 2021-05-10 22:56 -0400
Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-05-10 10:15 -0700
Re: Halting problem undecidability and infinite recursion [ Mike says Proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 11:17 -0500
Re: Halting problem undecidability and infinite recursion [sound deductive argument = proof ] olcott <NoOne@NoWhere.com> - 2021-06-27 21:35 -0500
Re: Halting problem undecidability and infinite recursion [sound deductive argument = proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-06-27 22:19 -0700
Page 4 of 5 — ← Prev page 1 2 3 [4] 5 Next page →
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-10 16:33 +0000 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <20210510091618.563@kylheku.com> |
| In reply to | #33254 |
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
> On 5/10/2021 12:32 AM, Kaz Kylheku wrote:
>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>
>>>> Me:
>>>> || (B) Every computation that halts, for whatever reason, is a halting
>>>> || computation.
>>>>
>>>> You:
>>>> | OK
>>>>
>>>> Are you retracting that now?
>>>>
>>>
>>>
>>> When the execution trace of H_Hat() correctly matches a correct
>>> non-halting behavior pattern then the decision of non-halting is
>>> impossibly incorrect.
>>
>> Problem is, you only declared it to be matching. It violates your rules
>> because Halts returns.
>
> Good catch.
>
> The rule had to be corrected
> (4) with no function call returns from X()
> was changed to this
> (4) with no function call returns from X() to Y()
>
OK, but then you have two problems.
1. The X function call is ultimately required to be a pure
function application, if you are to meet the conditions of the proof.
A function call doesn't "know" who is calling it; it cannot
calculate differently because of the identity of the caller.
2. When actual execution traces show Halts isn't behaving differently
based on who its caller is, and returning 0 to H_Hat
exactly as it does to main, you simmply declare observations of that
evidence to that off-topic, dishonest and non-discussable.
Then you assert that the conditions are still being detected.
I think you need need (4) to be:
"with no function call return from X to Y unless Y
is the top-level caller of X"
I mean, that matches what you've figured out to do in your apparatus.
You've found a way to get some recursive calls to not to return, other than
the top-level one. Only problem is, they are all the same call; because
the top-level one is a terminating calcultion terminating, so are the
others. They just don't reach termination because they are only
permitted N levels of simulation, and termination occurs in M > N
levels.
--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 11:49 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <zbCdnfF-eO-G-QT9nZ2dnUU7-KPNnZ2d@giganews.com> |
| In reply to | #33273 |
On 5/10/2021 11:33 AM, Kaz Kylheku wrote: > On 2021-05-10, olcott <NoOne@NoWhere.com> wrote: >> On 5/10/2021 12:32 AM, Kaz Kylheku wrote: >>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote: >>>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> H_Hat(H_Hat) only halts because it is aborted at some point. >>>>> >>>>> Me: >>>>> || (B) Every computation that halts, for whatever reason, is a halting >>>>> || computation. >>>>> >>>>> You: >>>>> | OK >>>>> >>>>> Are you retracting that now? >>>>> >>>> >>>> >>>> When the execution trace of H_Hat() correctly matches a correct >>>> non-halting behavior pattern then the decision of non-halting is >>>> impossibly incorrect. >>> >>> Problem is, you only declared it to be matching. It violates your rules >>> because Halts returns. >> >> Good catch. >> >> The rule had to be corrected >> (4) with no function call returns from X() >> was changed to this >> (4) with no function call returns from X() to Y() >> > OK, but then you have two problems. > > 1. The X function call is ultimately required to be a pure > function application, if you are to meet the conditions of the proof. > A function call doesn't "know" who is calling it; it cannot > calculate differently because of the identity of the caller. > It doesn't know who is calling it and it doesn't know when it has been aborted. > 2. When actual execution traces show Halts isn't behaving differently > based on who its caller is, and returning 0 to H_Hat > exactly as it does to main, you simmply declare observations of that > evidence to that off-topic, dishonest and non-discussable. > Then you assert that the conditions are still being detected. > Yes even very intelligent people that do have the technical capacity to provide an accurate technical review will resort to mere rhetoric when there is no actual reasoning that supports any real rebuttal and they are dead set on rebuttal as their highest priority. > I think you need need (4) to be: > > "with no function call return from X to Y unless Y > is the top-level caller of X" > No, not at all. There is never any case where any simulator ever returns to the input that it is simulating. > I mean, that matches what you've figured out to do in your apparatus. > You've found a way to get some recursive calls to not to return, other than > the top-level one. Only problem is, they are all the same call; because > the top-level one is a terminating calcultion terminating, so are the > others. They just don't reach termination because they are only > permitted N levels of simulation, and termination occurs in M > N > levels. > -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-10 16:58 +0000 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <20210510095418.388@kylheku.com> |
| In reply to | #33275 |
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote: > On 5/10/2021 11:33 AM, Kaz Kylheku wrote: >> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote: >>> On 5/10/2021 12:32 AM, Kaz Kylheku wrote: >>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote: >>>>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote: >>>>>> olcott <NoOne@NoWhere.com> writes: >>>>>> >>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point. >>>>>> >>>>>> Me: >>>>>> || (B) Every computation that halts, for whatever reason, is a halting >>>>>> || computation. >>>>>> >>>>>> You: >>>>>> | OK >>>>>> >>>>>> Are you retracting that now? >>>>>> >>>>> >>>>> >>>>> When the execution trace of H_Hat() correctly matches a correct >>>>> non-halting behavior pattern then the decision of non-halting is >>>>> impossibly incorrect. >>>> >>>> Problem is, you only declared it to be matching. It violates your rules >>>> because Halts returns. >>> >>> Good catch. >>> >>> The rule had to be corrected >>> (4) with no function call returns from X() >>> was changed to this >>> (4) with no function call returns from X() to Y() >>> >> OK, but then you have two problems. >> >> 1. The X function call is ultimately required to be a pure >> function application, if you are to meet the conditions of the proof. >> A function call doesn't "know" who is calling it; it cannot >> calculate differently because of the identity of the caller. >> > > It doesn't know who is calling it and it doesn't know when it has been > aborted. Your most recent execution traces indeed corroborate this in the sense of not providing contrary evidence. >> 2. When actual execution traces show Halts isn't behaving differently >> based on who its caller is, and returning 0 to H_Hat >> exactly as it does to main, you simmply declare observations of that >> evidence to that off-topic, dishonest and non-discussable. >> Then you assert that the conditions are still being detected. >> > > Yes even very intelligent people that do have the technical capacity to > provide an accurate technical review will resort to mere rhetoric when > there is no actual reasoning that supports any real rebuttal and they > are dead set on rebuttal as their highest priority. Right; so given that you grasp the full psychological intuition behind your argumentation, why do you persist in it? >> I think you need need (4) to be: >> >> "with no function call return from X to Y unless Y >> is the top-level caller of X" >> > > No, not at all. There is never any case where any simulator ever returns > to the input that it is simulating. You mean, other than the bit of evidence when H_Hat(H_Hat) contains the first, top-level call to Halts? Which is supposed to be ignored ... just because you don't like it or something? -- TXR Programming Language: http://nongnu.org/txr Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 12:09 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <k6ydnbFVxP4u9QT9nZ2dnUU7-cmdnZ2d@giganews.com> |
| In reply to | #33277 |
On 5/10/2021 11:58 AM, Kaz Kylheku wrote:
> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>> On 5/10/2021 11:33 AM, Kaz Kylheku wrote:
>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/10/2021 12:32 AM, Kaz Kylheku wrote:
>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>
>>>>>>> Me:
>>>>>>> || (B) Every computation that halts, for whatever reason, is a halting
>>>>>>> || computation.
>>>>>>>
>>>>>>> You:
>>>>>>> | OK
>>>>>>>
>>>>>>> Are you retracting that now?
>>>>>>>
>>>>>>
>>>>>>
>>>>>> When the execution trace of H_Hat() correctly matches a correct
>>>>>> non-halting behavior pattern then the decision of non-halting is
>>>>>> impossibly incorrect.
>>>>>
>>>>> Problem is, you only declared it to be matching. It violates your rules
>>>>> because Halts returns.
>>>>
>>>> Good catch.
>>>>
>>>> The rule had to be corrected
>>>> (4) with no function call returns from X()
>>>> was changed to this
>>>> (4) with no function call returns from X() to Y()
>>>>
>>> OK, but then you have two problems.
>>>
>>> 1. The X function call is ultimately required to be a pure
>>> function application, if you are to meet the conditions of the proof.
>>> A function call doesn't "know" who is calling it; it cannot
>>> calculate differently because of the identity of the caller.
>>>
>>
>> It doesn't know who is calling it and it doesn't know when it has been
>> aborted.
>
> Your most recent execution traces indeed corroborate this in the sense
> of not providing contrary evidence.
>
>>> 2. When actual execution traces show Halts isn't behaving differently
>>> based on who its caller is, and returning 0 to H_Hat
>>> exactly as it does to main, you simmply declare observations of that
>>> evidence to that off-topic, dishonest and non-discussable.
>>> Then you assert that the conditions are still being detected.
>>>
>>
>> Yes even very intelligent people that do have the technical capacity to
>> provide an accurate technical review will resort to mere rhetoric when
>> there is no actual reasoning that supports any real rebuttal and they
>> are dead set on rebuttal as their highest priority.
>
> Right; so given that you grasp the full psychological intuition behind
> your argumentation, why do you persist in it?
>
>>> I think you need need (4) to be:
>>>
>>> "with no function call return from X to Y unless Y
>>> is the top-level caller of X"
>>>
>>
>> No, not at all. There is never any case where any simulator ever returns
>> to the input that it is simulating.
>
> You mean, other than the bit of evidence when H_Hat(H_Hat) contains the
> first, top-level call to Halts?
>
> Which is supposed to be ignored ... just because you don't like it or
> something?
>
When an execution trace matches the following criteria we know that the
non-halting behavior of infinite recursion or infinitely nested
simulation has been matched:
If the execution trace of function Y() shows:
(1) function X() is called twice in sequence from the same machine
address of Y()
(2) with the same parameters to X()
(3) with no conditional branch or indexed jump instructions in Y()
(4) with no function call returns from X() to Y()
then the function call from Y() to X() is infinitely recursive.
There are only two possibilities that Halts(H_Hat, H_Hat) == 0 is incorrect:
(1) The above criteria is incorrect.
(2) The behavior of H_Hat() does not match the above criteria
How much longer are you going to dishonestly avoid this direct review?
--
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-05-10 11:54 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <87a6p2x3j0.fsf@bsb.me.uk> |
| In reply to | #33226 |
olcott <NoOne@NoWhere.com> writes: > On 5/9/2021 8:31 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> H_Hat(H_Hat) only halts because it is aborted at some point. >> >> Me: >> || (B) Every computation that halts, for whatever reason, is a halting >> || computation. >> >> You: >> | OK >> >> Are you retracting that now? So you still agree. Good. > When the execution trace of H_Hat() correctly matches a correct > non-halting behavior pattern then the decision of non-halting is > impossibly incorrect. The name is not magic, nor is any declaration that something is "impossibly incorrect". If the pattern is wrong, or incorrectly applied, or your code is otherwise buggy, the answer will be wrong, as it is in this case. I'll be able to say which when you post the full code (i.e. never). > Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct > and we know that H_Hat(H_Hat) halts what could explain this? The explanation is simple: the code for Halts gives the wrong answer. The correct answer for every computation that halts, for whatever reason, is true (or 1 or yes). > They are different computations? `Halts(H_Hat, H_Hat)' and `H_Hat(H_Hat)' are indeed different computations. Both halt. There is no non-halting computation anywhere to be seen. The arguments to Halts in `Halts(H_Hat, H_Hat)' denote the halting computation `H_Hat(H_hat)'. The correct answer for any and all halting computations is true. After more than 15 years claiming to work on the halting problem you should at least know what it is. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 08:21 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <QP6dnfRwvon9rgT9nZ2dnUU7-LXNnZ2d@giganews.com> |
| In reply to | #33251 |
On 5/10/2021 5:54 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 5/9/2021 8:31 PM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> H_Hat(H_Hat) only halts because it is aborted at some point. >>> >>> Me: >>> || (B) Every computation that halts, for whatever reason, is a halting >>> || computation. >>> >>> You: >>> | OK >>> >>> Are you retracting that now? > > So you still agree. Good. > >> When the execution trace of H_Hat() correctly matches a correct >> non-halting behavior pattern then the decision of non-halting is >> impossibly incorrect. > > The name is not magic, nor is any declaration that something is > "impossibly incorrect". If the pattern is wrong, or incorrectly > applied, or your code is otherwise buggy, the answer will be wrong, as > it is in this case. I'll be able to say which when you post the full > code (i.e. never). > If that was the case then someone could find the specific error. Kaz caught this error that has now been corrected. The rule had to be corrected (4) with no function call returns from X() was changed to this (4) with no function call returns from X() to Y() No simulator every returns to the program that it is simulating. >> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct >> and we know that H_Hat(H_Hat) halts what could explain this? > > The explanation is simple: the code for Halts gives the wrong > answer. So you don't know what a hypothetical is. > The correct answer for every computation that halts, for > whatever reason, is true (or 1 or yes). The partial simulation X of a computation Y that is forced to stop because the computation Y specifies infinite execution is a computation Y that halts and yet remains a non-halting computation. >> They are different computations? > > `Halts(H_Hat, H_Hat)' and `H_Hat(H_Hat)' are indeed different > computations. Both halt. There is no non-halting computation anywhere > to be seen. When an execution trace matches the following criteria we know that the non-halting behavior of infinite recursion or infinitely nested simulation has been matched: If the execution trace of function Y() shows: (1) function X() is called twice in sequence from the same machine address of Y() (2) with the same parameters to X() (3) with no conditional branch or indexed jump instructions in Y() (4) with no function call returns from X() to Y() then the function call from Y() to X() is infinitely recursive. The fact that the behavior of H_Hat() correctly matches the above correct non-halting behavior pattern proves that Halts(H_Hat, H_Hat) == 0 is correct. THERE IS NO ESCAPE FROM THIS > The arguments to Halts in `Halts(H_Hat, H_Hat)' denote the > halting computation `H_Hat(H_hat)'. The correct answer for any and all > halting computations is true. After more than 15 years claiming to work > on the halting problem you should at least know what it is. > -- 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-05-10 17:00 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <87r1ie60l9.fsf@bsb.me.uk> |
| In reply to | #33256 |
olcott <NoOne@NoWhere.com> writes: > On 5/10/2021 5:54 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >>>> >>>>> H_Hat(H_Hat) only halts because it is aborted at some point. >>>> >>>> Me: >>>> || (B) Every computation that halts, for whatever reason, is a halting >>>> || computation. >>>> >>>> You: >>>> | OK >>>> >>>> Are you retracting that now? >> >> So you still agree. Good. >> >>> When the execution trace of H_Hat() correctly matches a correct >>> non-halting behavior pattern then the decision of non-halting is >>> impossibly incorrect. >> >> The name is not magic, nor is any declaration that something is >> "impossibly incorrect". If the pattern is wrong, or incorrectly >> applied, or your code is otherwise buggy, the answer will be wrong, as >> it is in this case. I'll be able to say which when you post the full >> code (i.e. never). > > If that was the case then someone could find the specific error. Bad logic. I am certain that no one, not even Kaz, will state that he knows exactly where the error is. By the way, I also found an error but you refused to look at the trace. > Kaz caught this error that has now been corrected. > > The rule had to be corrected > (4) with no function call returns from X() > was changed to this > (4) with no function call returns from X() to Y() As he has pointed out (and I think you ignored) this is a silly condition. You probably don't mean what it says, but since your Halts gets the wrong answer, finding out exactly why is just a side show. > No simulator every returns to the program that it is simulating. > >>> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct >>> and we know that H_Hat(H_Hat) halts what could explain this? >> >> The explanation is simple: the code for Halts gives the wrong >> answer. > > So you don't know what a hypothetical is. Don't be silly. If you intended both statements to be one combined hypothesis (e.g. "hypothetically if 1 = 2 and 1 =/= 2...") then there is nothing to explain. If you a proposing two hypotheses then one is right and the other is wrong. >> The correct answer for every computation that halts, for >> whatever reason, is true (or 1 or yes). > > The partial simulation X of a computation Y that is forced to stop > because the computation Y specifies infinite execution is a > computation Y that halts and yet remains a non-halting computation. Stop this silly language. Nothing forces any code to do anything. A a computation is or is not finite. It does not "remain" anything. It is what it is. But when the language is sorted out, this is a correct statement about two computations. You keep trying to find a sneaky way to go from two computations (X a halting partial simulation of a non-halting Y) to one computation where the X is embedded in Y. >>> They are different computations? >> >> `Halts(H_Hat, H_Hat)' and `H_Hat(H_Hat)' are indeed different >> computations. Both halt. There is no non-halting computation anywhere >> to be seen. > > When an execution trace matches the following criteria we know that > the non-halting behavior of infinite recursion or infinitely nested > simulation has been matched: That criterion is either badly named, incorrect, incorrectly applied, or Halts has some other bugs (or, likely as not, some combination of these). That's how software works. Halts fails to meet the specification so it's not detecting halting. > If the execution trace of function Y() shows: > (1) function X() is called twice in sequence from the same machine address of Y() > (2) with the same parameters to X() > (3) with no conditional branch or indexed jump instructions in Y() > (4) with no function call returns from X() to Y() > then the function call from Y() to X() is infinitely recursive. I have a trace that shows this is wrong (or maybe badly worded since (4) is impossible to detect as stated). > The fact that the behavior of H_Hat() correctly matches the above > correct non-halting behavior pattern proves that Halts(H_Hat, H_Hat) > == 0 is correct. THERE IS NO ESCAPE FROM THIS Don't be silly. The correct return for halting computations is 1 not 0. No waffle about what pattern you think you may have matched can make the wrong answer right. Your job is to find out where the bug is, not to tell everyone there is no bug because 0 is the right answer. >> The arguments to Halts in `Halts(H_Hat, H_Hat)' denote the >> halting computation `H_Hat(H_hat)'. The correct answer for any and all >> halting computations is true. After more than 15 years claiming to work >> on the halting problem you should at least know what it is. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 11:22 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <VuSdnbISCN9VwAT9nZ2dnUU7-VvNnZ2d@giganews.com> |
| In reply to | #33268 |
On 5/10/2021 11:00 AM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 5/10/2021 5:54 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: >>> >>>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote: >>>>> olcott <NoOne@NoWhere.com> writes: >>>>> >>>>>> H_Hat(H_Hat) only halts because it is aborted at some point. >>>>> >>>>> Me: >>>>> || (B) Every computation that halts, for whatever reason, is a halting >>>>> || computation. >>>>> >>>>> You: >>>>> | OK >>>>> >>>>> Are you retracting that now? >>> >>> So you still agree. Good. >>> >>>> When the execution trace of H_Hat() correctly matches a correct >>>> non-halting behavior pattern then the decision of non-halting is >>>> impossibly incorrect. >>> >>> The name is not magic, nor is any declaration that something is >>> "impossibly incorrect". If the pattern is wrong, or incorrectly >>> applied, or your code is otherwise buggy, the answer will be wrong, as >>> it is in this case. I'll be able to say which when you post the full >>> code (i.e. never). >> >> If that was the case then someone could find the specific error. > > Bad logic. I am certain that no one, not even Kaz, will state that he > knows exactly where the error is. > > By the way, I also found an error but you refused to look at the trace. > >> Kaz caught this error that has now been corrected. >> >> The rule had to be corrected >> (4) with no function call returns from X() >> was changed to this >> (4) with no function call returns from X() to Y() > > As he has pointed out (and I think you ignored) this is a silly > condition. You probably don't mean what it says, but since your Halts > gets the wrong answer, finding out exactly why is just a side show. > >> No simulator every returns to the program that it is simulating. >> >>>> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct >>>> and we know that H_Hat(H_Hat) halts what could explain this? >>> >>> The explanation is simple: the code for Halts gives the wrong >>> answer. >> >> So you don't know what a hypothetical is. > > Don't be silly. If you intended both statements to be one combined > hypothesis (e.g. "hypothetically if 1 = 2 and 1 =/= 2...") then there is > nothing to explain. If you a proposing two hypotheses then one is right > and the other is wrong. > >>> The correct answer for every computation that halts, for >>> whatever reason, is true (or 1 or yes). >> >> The partial simulation X of a computation Y that is forced to stop >> because the computation Y specifies infinite execution is a >> computation Y that halts and yet remains a non-halting computation. > > Stop this silly language. Nothing forces any code to do anything. A a > computation is or is not finite. It does not "remain" anything. It is > what it is. But when the language is sorted out, this is a correct > statement about two computations. > > You keep trying to find a sneaky way to go from two computations (X a > halting partial simulation of a non-halting Y) to one computation where > the X is embedded in Y. > >>>> They are different computations? >>> >>> `Halts(H_Hat, H_Hat)' and `H_Hat(H_Hat)' are indeed different >>> computations. Both halt. There is no non-halting computation anywhere >>> to be seen. >> >> When an execution trace matches the following criteria we know that >> the non-halting behavior of infinite recursion or infinitely nested >> simulation has been matched: > > That criterion is either badly named, incorrect, incorrectly applied, or > Halts has some other bugs (or, likely as not, some combination of > these). That's how software works. Halts fails to meet the > specification so it's not detecting halting. > >> If the execution trace of function Y() shows: >> (1) function X() is called twice in sequence from the same machine address of Y() >> (2) with the same parameters to X() >> (3) with no conditional branch or indexed jump instructions in Y() >> (4) with no function call returns from X() to Y() >> then the function call from Y() to X() is infinitely recursive. > > I have a trace that shows this is wrong (or maybe badly worded since (4) > is impossible to detect as stated). Since no simulator ever returns to the code that it is simulating in the case of a match of the above pattern for infinitely nested simulation (4) is a tautology. >> The fact that the behavior of H_Hat() correctly matches the above >> correct non-halting behavior pattern proves that Halts(H_Hat, H_Hat) >> == 0 is correct. THERE IS NO ESCAPE FROM THIS > > Don't be silly. The correct return for halting computations is 1 not > 0. No waffle about what pattern you think you may have matched can make > the wrong answer right. Your job is to find out where the bug is, not > to tell everyone there is no bug because 0 is the right answer. > >>> The arguments to Halts in `Halts(H_Hat, H_Hat)' denote the >>> halting computation `H_Hat(H_hat)'. The correct answer for any and all >>> halting computations is true. After more than 15 years claiming to work >>> on the halting problem you should at least know what it is. > -- 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-05-10 23:59 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <87czty5h5x.fsf@bsb.me.uk> |
| In reply to | #33271 |
olcott <NoOne@NoWhere.com> writes: > On 5/10/2021 11:00 AM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >>> If the execution trace of function Y() shows: >>> (1) function X() is called twice in sequence from the same machine address of Y() >>> (2) with the same parameters to X() >>> (3) with no conditional branch or indexed jump instructions in Y() >>> (4) with no function call returns from X() to Y() >>> then the function call from Y() to X() is infinitely recursive. >> >> I have a trace that shows this is wrong (or maybe badly worded since (4) >> is impossible to detect as stated). > > Since no simulator ever returns to the code that it is simulating in > the case of a match of the above pattern for infinitely nested > simulation So you've been lying to us all this time? Rule (4) is not about function call returning to the function that called it, but its about a simulator doing something that is impossible? No, you have not been lying, you are just flip-flopping between calling and simulating in order to cloud the issue. > (4) is a tautology. Then it would not need to be stated. I don't think you know what the word means. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 18:05 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <drednRKFN7pqJgT9nZ2dnUU7-U-dnZ2d@giganews.com> |
| In reply to | #33294 |
On 5/10/2021 5:59 PM, Ben Bacarisse wrote: > olcott <NoOne@NoWhere.com> writes: > >> On 5/10/2021 11:00 AM, Ben Bacarisse wrote: >>> olcott <NoOne@NoWhere.com> writes: > >>>> If the execution trace of function Y() shows: >>>> (1) function X() is called twice in sequence from the same machine address of Y() >>>> (2) with the same parameters to X() >>>> (3) with no conditional branch or indexed jump instructions in Y() >>>> (4) with no function call returns from X() to Y() >>>> then the function call from Y() to X() is infinitely recursive. >>> >>> I have a trace that shows this is wrong (or maybe badly worded since (4) >>> is impossible to detect as stated). >> >> Since no simulator ever returns to the code that it is simulating in >> the case of a match of the above pattern for infinitely nested >> simulation > > So you've been lying to us all this time? Rule (4) is not about > function call returning to the function that called it, but its about a > simulator doing something that is impossible? No, you have not been > lying, you are just flip-flopping between calling and simulating in > order to cloud the issue. > >> (4) is a tautology. > > Then it would not need to be stated. I don't think you know what the > word means. > In all the many years that we have spoken you have never shown any software engineering technical competence. -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Jeff Barnett <jbb@notatt.com> |
|---|---|
| Date | 2021-05-10 17:33 -0600 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <s7cfsn$1r0$1@dont-email.me> |
| In reply to | #33295 |
On 5/10/2021 5:05 PM, olcott wrote:
> On 5/10/2021 5:59 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
<snip>
> In all the many years that we have spoken you have never shown any
> software engineering technical competence.
If that were true (it isn't) you would finally be having a conversation
with an equal. And that would be a rare experience for you in these
forums. Actually I'm starting to find you rather clever with words, not
technical things. Even with words that you do not understand.
----------------------------------------------------------------------
I'm going to repeat a speculation that I uttered several months ago. You
are not human. The snippets of your court case(s) and patent were all
faked and planted to create an on-line individual, i.e., a bot, mostly
powered by something like the original Eliza program with a few modern
trimmings. I conjecture that the genius behind all of this is proving
the Chinese Room is really a possibilities. The affectations of
trolling, pig-headed personality, compulsive retention, idee fixe, and
so on are merely there to mask an imperfect portrayal of a human. And to
think that I once suggested that you have sex to clear your head. That
wouldn't do anything for a computer process would it? It now seems that
the only way to get our newsgroup back would be to unplug "you".
A philosophical question: when I use pronouns like 'you' and 'yours'
above, should they be enclosed in quotes, i.e., should they appear as
"you" and "yours"? I guess that depends on far we think this Eliza
simulation has approached consciousness.
Would you please have your creating programmer field these questions.
That could afford us all an opportunity to discuss how s/he produced
some of the special effects that shine thru all of these messages.
--
Jeff Barnett
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-11 02:03 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) |
| Message-ID | <874kfa3wv4.fsf@bsb.me.uk> |
| In reply to | #33295 |
olcott <NoOne@NoWhere.com> writes: > On 5/10/2021 5:59 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> On 5/10/2021 11:00 AM, Ben Bacarisse wrote: >>>> olcott <NoOne@NoWhere.com> writes: >> >>>>> If the execution trace of function Y() shows: >>>>> (1) function X() is called twice in sequence from the same machine address of Y() >>>>> (2) with the same parameters to X() >>>>> (3) with no conditional branch or indexed jump instructions in Y() >>>>> (4) with no function call returns from X() to Y() >>>>> then the function call from Y() to X() is infinitely recursive. >>>> >>>> I have a trace that shows this is wrong (or maybe badly worded since (4) >>>> is impossible to detect as stated). >>> >>> Since no simulator ever returns to the code that it is simulating in >>> the case of a match of the above pattern for infinitely nested >>> simulation >> >> So you've been lying to us all this time? Rule (4) is not about >> function call returning to the function that called it, but its about a >> simulator doing something that is impossible? No, you have not been >> lying, you are just flip-flopping between calling and simulating in >> order to cloud the issue. >> >>> (4) is a tautology. >> >> Then it would not need to be stated. I don't think you know what the >> word means. > > In all the many years that we have spoken you have never shown any > software engineering technical competence. Thank you. -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-10 02:28 +0100 |
| Message-ID | <87lf8nwf5h.fsf@bsb.me.uk> |
| In reply to | #33206 |
olcott <NoOne@NoWhere.com> writes: > On 5/9/2021 5:32 PM, Ben Bacarisse wrote: >> olcott <NoOne@NoWhere.com> writes: >> >>> I have correctly refuted the conventional halting problem proofs. >> >> No. In fifteen years you have not been able to show an single error in >> any proof. >> >> Your recent posts are not even about the halting problem because you >> don't accept that the correct answer for all pairs that denote halting >> computations is "yes", and "no" for all other inputs. In fact, you even >> doubt that halting entails halting: >> >> "the fact that a computation halts does not entail that it is a halting >> computation" Peter Olcott, May 2021. > > I will try to make my words more precise: > > That the computation (of the partial simulation of an infinite loop) > halts does not entail that the infinite loop is a halting computation. Trivially true, whereas your previous words where logical garbage. This is about two different computations whereas your garbage statement is about one (though I accept you did not intend to write what you did). > That the computation (of the partial simulation of an X) halts does > not entail that the X is a halting computation. Also a trivially true statement about two different computations. If you no longer stand by your original nonsensical statement, you need to say so, not pretend that two trivially true remarks are just making the garbage "more precise". -- Ben.
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2021-05-10 04:03 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion (PO=Deluded Dumbo) |
| Message-ID | <Yd6dne54j43zPwX9nZ2dnUU78S3NnZ2d@brightview.co.uk> |
| In reply to | #33201 |
On 09/05/2021 22:04, olcott wrote: > On 5/9/2021 4:00 PM, Siri Cruise wrote: >> In article <0vednVI61bCe0QX9nZ2dnUU7-U3NnZ2d@giganews.com>, >> olcott <NoOne@NoWhere.com> wrote: >> >>> When we base halting on answering questions that currently have no known >>> answers this does not derive the conventional notion of halting >>> undecidability. It is not the case that the correct answer is impossible >>> to provide, we just don't know what that answer is right now. >> >> In other words you can solve whether a specific TM will halt >> after someone else proves whether it will halt. That's a really >> impressive skill. >> > > I have correctly refuted the conventional halting problem proofs. Dude! I'm afraid your mind is pretty much incapable of any/all abstract reasoning, which means you can't properly understand even simple abstract concepts and definitions that underly the theorems you claim to "refute". - You claim to refute the Halting Problem proof, but you show you don't understand the concepts of "halting" or "TM" or "computation" or even what a "decision problem" means, and so on and on. Let's not get into how you're using C together with your x86utm.exe instead of TMs, and exactly how that corresponds with the proofs in Linz/Sipser. You don't even see the problems here, and just waffle your way through them with your magical "equivalent calculation" mantra... - You claim to refute Tarski's theorem on the undefineability of truth, but you don't understand Tarski's concept of truth, or what the phrase "undefineability" means. (But hey, other than that I guess you're on a roll.) - You claim to have refuted the uncountability of the real numbers, but you don't understand the mathematical concepts of function, set, countability, or real numbers, and your own definitions you come up with are incoherent etc.. (Yeah, we know you can use Google.) - You claim to have refuted the Godel Incompleteness Theorem, but you don't understand what a formal system of logic is, what a "proof" in a formal system is, or, um, anything really. - You claimed a while back to have "refuted" the Banach Tarski theorem, but it turned out (suprise!) you couldn't actually understand the concepts involved in its statement (mapping, set, decomposition, in fact ANY relevent idea in the proof!) - You claim to have refuted Rice's theorem. Um, nuff said... (Talk about "pretentious"...) [In all the above I think I could make a stab at a reasonable case that it is a problem with "abstract thinking" specifically which is your root problem. E.g. you don't understand TMs as a mathematical construct, so instead you have to imagine it as some kind of actual running computer; you don't understand the abstract definition of computation or halting, so instead you have to replace it with /simulations/ of stuff and confuse yourself; you don't understand what Tarski means by "truth", so all you're able to do is talk about "provability" which at least is a somewhat more concrete procedural-based idea.] And of course the biggie: any /proof/ requires some apptitude with abstract reasoning, so there's really ZERO chance you could ever produce a genuine proof to support any of your boasts. I think you at least know that much, which is why you post endlessly on Usenet instead of actually just "proving" your claims and getting them published. Anything you present to a reputable journal for publishing is just going straight in the bin without even wasting the time of a peer-reviewer! > If you are saying that is of no consequence people sufficiently > understanding these proofs would disagree. > But, but, but... you're overlooking your other major aspect - you have a completely delusional view of the world and your place in the world. You need to keep in mind: you're not /just/ a Dumbo, you're a Delusional Dumbo. (Most people in the world don't have the aptitude to engage in research level work in a technical field, but lacking your delusional framework they just know to do something else and get on with their lives. No problem.) You arrogantly believe the people you deal with here on Usenet are stupid (and on Stack Exchange, Quora, Reddit and wherever else you go), and often accuse them of /lying/ for some reason. You think that when you finally get to communicate with a "real software engineer" or "real computer scientist" of the appropriate intelligence they'll of course understand and agree with whatever you claim. Needless to say, that's pure delusional thinking. Those peer reviewers you're aiming at (if you ever got through to them) are just going to be MORE "intellectually sharp" and all-round "technically clued up" across the whole field than people here. In your delusions, they will be just like YOU, not understanding the basic definitions or what constitutes a proof, and willing to accept unsupported claims just because you find them intuitive, and so on. Even though you're delusional, surely common sense must tell you that peer reviewers are in the position they are, precisely /because/ they have all that basic stuff COMPLETELY NAILED? If you can't convince people here, you're not going to get /anywhere/ in a much more formal environment! [Yeah, Dunning-Kruger and all that, but DK is actually a /normal/ cognitive bias - if someone didn't have it that would be abnormal. I suspect DK is over-quoted on Usenet and elsewhere by non-psychologists, and I doubt it would be the right term to describe PO's probems. But perhaps there's a "unchecked DK" or "mega-DK syndrome" or something. Anyway, PO's delusions go far further than just DK - there's his belief he is God, and can (at times?) control other people to do what he wants, and his whole conception of what he will ultimately achieve with all this Usenet posting and so on.] Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 22:25 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion [ necessarily(P) ] |
| Message-ID | <k6WdndaWJKAPOgX9nZ2dnUU7-c3NnZ2d@giganews.com> |
| In reply to | #33240 |
On 5/9/2021 10:03 PM, Mike Terry wrote: > On 09/05/2021 22:04, olcott wrote: >> On 5/9/2021 4:00 PM, Siri Cruise wrote: >>> In article <0vednVI61bCe0QX9nZ2dnUU7-U3NnZ2d@giganews.com>, >>> olcott <NoOne@NoWhere.com> wrote: >>> >>>> When we base halting on answering questions that currently have no >>>> known >>>> answers this does not derive the conventional notion of halting >>>> undecidability. It is not the case that the correct answer is >>>> impossible >>>> to provide, we just don't know what that answer is right now. >>> >>> In other words you can solve whether a specific TM will halt >>> after someone else proves whether it will halt. That's a really >>> impressive skill. >>> >> >> I have correctly refuted the conventional halting problem proofs. > > Dude! I'm afraid your mind is pretty much incapable of any/all abstract > reasoning, which means you can't properly understand even simple > abstract concepts and definitions that underly the theorems you claim to > "refute". **My whole proof is boiled down to as simple as this:** When the execution trace of H_Hat() correctly matches a correct non-halting behavior pattern then the decision of non-halting is impossibly incorrect: AKA modal logic necessarily(P) When an execution trace matches the following criteria we know that the non-halting behavior of infinite recursion or infinitely nested simulation has been matched: If the execution trace of function Y() shows: (1) function X() is called twice in sequence from the same machine address of Y() (2) with the same parameters to X() (3) with no conditional branch or indexed jump instructions in Y() (4) with no function call returns from X() then the function call from Y() to X() is infinitely recursive. The execution trace of H_Hat() shows that its behavior matches the above non-halting criteria thus the only possible way that Halts(H_Hat, H_Hat) == 0 is incorrect is that the criteria is incorrect. http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2021-05-10 16:18 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] |
| Message-ID | <A-WdnTwwv6tb0wT9nZ2dnUU78KHNnZ2d@brightview.co.uk> |
| In reply to | #33244 |
On 10/05/2021 04:25, olcott wrote: > On 5/9/2021 10:03 PM, Mike Terry wrote: >> On 09/05/2021 22:04, olcott wrote: >>> On 5/9/2021 4:00 PM, Siri Cruise wrote: >>>> In article <0vednVI61bCe0QX9nZ2dnUU7-U3NnZ2d@giganews.com>, >>>> olcott <NoOne@NoWhere.com> wrote: >>>> >>>>> When we base halting on answering questions that currently have no >>>>> known >>>>> answers this does not derive the conventional notion of halting >>>>> undecidability. It is not the case that the correct answer is >>>>> impossible >>>>> to provide, we just don't know what that answer is right now. >>>> >>>> In other words you can solve whether a specific TM will halt >>>> after someone else proves whether it will halt. That's a really >>>> impressive skill. >>>> >>> >>> I have correctly refuted the conventional halting problem proofs. >> >> Dude! I'm afraid your mind is pretty much incapable of any/all >> abstract reasoning, which means you can't properly understand even >> simple abstract concepts and definitions that underly the theorems you >> claim to "refute". > > **My whole proof is boiled down to as simple as this:** > When the execution trace of H_Hat() correctly matches a correct > non-halting behavior pattern then the decision of non-halting is > impossibly incorrect: AKA modal logic necessarily(P) > > When an execution trace matches the following criteria we know that the > non-halting behavior of infinite recursion or infinitely nested > simulation has been matched: > > If the execution trace of function Y() shows: > (1) function X() is called twice in sequence from the same machine > address of Y() > (2) with the same parameters to X() > (3) with no conditional branch or indexed jump instructions in Y() > (4) with no function call returns from X() > then the function call from Y() to X() is infinitely recursive. You cut the lines that said you were intellectually incapable of producing any kind of proof, because you don't understand what a proof actually is. The above is not a proof of anything. If you're going to submit an article for peer review, the reviewer will expect there to be a proof of any claims you make. So perhaps you have some kind of proof of the above claims for (1)-(4) somewhere? (I suggested you should do this 6 months ago, but nothing was forthcoming apart from your "I'm making it an axiom" nonsense. Also, if you're claiming to have refuted the Linz/Sipser/similar HP proof, they will expect you to say where exactly the error is in those proofs. Saying "my computer program shows they're wrong" won't cut it! (But feel free to try that anyway...) Regards, Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 10:25 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] |
| Message-ID | <6PqdnWV0Fc3BzQT9nZ2dnUU7-I_NnZ2d@giganews.com> |
| In reply to | #33263 |
On 5/10/2021 10:18 AM, Mike Terry wrote: > On 10/05/2021 04:25, olcott wrote: >> On 5/9/2021 10:03 PM, Mike Terry wrote: >>> On 09/05/2021 22:04, olcott wrote: >>>> On 5/9/2021 4:00 PM, Siri Cruise wrote: >>>>> In article <0vednVI61bCe0QX9nZ2dnUU7-U3NnZ2d@giganews.com>, >>>>> olcott <NoOne@NoWhere.com> wrote: >>>>> >>>>>> When we base halting on answering questions that currently have no >>>>>> known >>>>>> answers this does not derive the conventional notion of halting >>>>>> undecidability. It is not the case that the correct answer is >>>>>> impossible >>>>>> to provide, we just don't know what that answer is right now. >>>>> >>>>> In other words you can solve whether a specific TM will halt >>>>> after someone else proves whether it will halt. That's a really >>>>> impressive skill. >>>>> >>>> >>>> I have correctly refuted the conventional halting problem proofs. >>> >>> Dude! I'm afraid your mind is pretty much incapable of any/all >>> abstract reasoning, which means you can't properly understand even >>> simple abstract concepts and definitions that underly the theorems >>> you claim to "refute". >> >> **My whole proof is boiled down to as simple as this:** >> When the execution trace of H_Hat() correctly matches a correct >> non-halting behavior pattern then the decision of non-halting is >> impossibly incorrect: AKA modal logic necessarily(P) >> >> When an execution trace matches the following criteria we know that >> the non-halting behavior of infinite recursion or infinitely nested >> simulation has been matched: >> >> If the execution trace of function Y() shows: >> (1) function X() is called twice in sequence from the same machine >> address of Y() >> (2) with the same parameters to X() >> (3) with no conditional branch or indexed jump instructions in Y() >> (4) with no function call returns from X() >> then the function call from Y() to X() is infinitely recursive. > > You cut the lines that said you were intellectually incapable of > producing any kind of proof, because Ad hominem is a dishonest Jackass move used by people that insist on disagreement at the expense of truth. From what I recall you are not a clueless wonder that has nothing more than ad hominem. From what I recall you are capable of an accurate technical review. I dare you to provide such an accurate technical review of this: **My whole proof is boiled down to as simple as this:** When the execution trace of H_Hat() correctly matches a correct non-halting behavior pattern then the decision of non-halting is necessarily correct. http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf -- Copyright 2021 Pete Olcott "Great spirits have always encountered violent opposition from mediocre minds." Einstein
[toc] | [prev] | [next] | [standalone]
| From | Mike Terry <news.dead.person.stones@darjeeling.plus.com> |
|---|---|
| Date | 2021-05-10 17:27 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] |
| Message-ID | <AK2dna-b97ZswwT9nZ2dnUU78YvNnZ2d@brightview.co.uk> |
| In reply to | #33264 |
On 10/05/2021 16:25, olcott wrote: > On 5/10/2021 10:18 AM, Mike Terry wrote: >> On 10/05/2021 04:25, olcott wrote: >>> On 5/9/2021 10:03 PM, Mike Terry wrote: >>>> On 09/05/2021 22:04, olcott wrote: >>>>> On 5/9/2021 4:00 PM, Siri Cruise wrote: >>>>>> In article <0vednVI61bCe0QX9nZ2dnUU7-U3NnZ2d@giganews.com>, >>>>>> olcott <NoOne@NoWhere.com> wrote: >>>>>> >>>>>>> When we base halting on answering questions that currently have >>>>>>> no known >>>>>>> answers this does not derive the conventional notion of halting >>>>>>> undecidability. It is not the case that the correct answer is >>>>>>> impossible >>>>>>> to provide, we just don't know what that answer is right now. >>>>>> >>>>>> In other words you can solve whether a specific TM will halt >>>>>> after someone else proves whether it will halt. That's a really >>>>>> impressive skill. >>>>>> >>>>> >>>>> I have correctly refuted the conventional halting problem proofs. >>>> >>>> Dude! I'm afraid your mind is pretty much incapable of any/all >>>> abstract reasoning, which means you can't properly understand even >>>> simple abstract concepts and definitions that underly the theorems >>>> you claim to "refute". >>> >>> **My whole proof is boiled down to as simple as this:** >>> When the execution trace of H_Hat() correctly matches a correct >>> non-halting behavior pattern then the decision of non-halting is >>> impossibly incorrect: AKA modal logic necessarily(P) >>> >>> When an execution trace matches the following criteria we know that >>> the non-halting behavior of infinite recursion or infinitely nested >>> simulation has been matched: >>> >>> If the execution trace of function Y() shows: >>> (1) function X() is called twice in sequence from the same machine >>> address of Y() >>> (2) with the same parameters to X() >>> (3) with no conditional branch or indexed jump instructions in Y() >>> (4) with no function call returns from X() >>> then the function call from Y() to X() is infinitely recursive. >> >> You cut the lines that said you were intellectually incapable of >> producing any kind of proof, because > Ad hominem is a dishonest Jackass move used by people that insist on > disagreement at the expense of truth. > I am stopping at your first major error. You do not understand what ad-hominem means. I did not say your proof was incorrect because you're incapable of abstract reasoning - I said that what you post above IS NOT A PROOF OF ANYTHING. There is literally no proof for me to review! Mike.
[toc] | [prev] | [next] | [standalone]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 11:37 -0500 |
| Subject | Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] |
| Message-ID | <foWdncbbTOvG_AT9nZ2dnUU7-R-dnZ2d@giganews.com> |
| In reply to | #33272 |
On 5/10/2021 11:27 AM, Mike Terry wrote:
> On 10/05/2021 16:25, olcott wrote:
>> On 5/10/2021 10:18 AM, Mike Terry wrote:
>>> On 10/05/2021 04:25, olcott wrote:
>>>> On 5/9/2021 10:03 PM, Mike Terry wrote:
>>>>> On 09/05/2021 22:04, olcott wrote:
>>>>>> On 5/9/2021 4:00 PM, Siri Cruise wrote:
>>>>>>> In article <0vednVI61bCe0QX9nZ2dnUU7-U3NnZ2d@giganews.com>,
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> When we base halting on answering questions that currently have
>>>>>>>> no known
>>>>>>>> answers this does not derive the conventional notion of halting
>>>>>>>> undecidability. It is not the case that the correct answer is
>>>>>>>> impossible
>>>>>>>> to provide, we just don't know what that answer is right now.
>>>>>>>
>>>>>>> In other words you can solve whether a specific TM will halt
>>>>>>> after someone else proves whether it will halt. That's a really
>>>>>>> impressive skill.
>>>>>>>
>>>>>>
>>>>>> I have correctly refuted the conventional halting problem proofs.
>>>>>
>>>>> Dude! I'm afraid your mind is pretty much incapable of any/all
>>>>> abstract reasoning, which means you can't properly understand even
>>>>> simple abstract concepts and definitions that underly the theorems
>>>>> you claim to "refute".
>>>>
>>>> **My whole proof is boiled down to as simple as this:**
>>>> When the execution trace of H_Hat() correctly matches a correct
>>>> non-halting behavior pattern then the decision of non-halting is
>>>> impossibly incorrect: AKA modal logic necessarily(P)
>>>>
>>>> When an execution trace matches the following criteria we know that
>>>> the non-halting behavior of infinite recursion or infinitely nested
>>>> simulation has been matched:
>>>>
>>>> If the execution trace of function Y() shows:
>>>> (1) function X() is called twice in sequence from the same machine
>>>> address of Y()
>>>> (2) with the same parameters to X()
>>>> (3) with no conditional branch or indexed jump instructions in Y()
>>>> (4) with no function call returns from X()
>>>> then the function call from Y() to X() is infinitely recursive.
>>>
>>> You cut the lines that said you were intellectually incapable of
>>> producing any kind of proof, because
>> Ad hominem is a dishonest Jackass move used by people that insist on
>> disagreement at the expense of truth.
>>
> I am stopping at your first major error. You do not understand what
> ad-hominem means. I did not say your proof was incorrect because you're
> incapable of abstract reasoning - I said that what you post above IS NOT
> A PROOF OF ANYTHING. There is literally no proof for me to review!
>
>
> Mike.
>
And yet you already agreed that my current proof is correct:
http://www.liarparadox.org/Halting_problem_undecidability_and_infinite_recursion.pdf
On 11/20/2020 9:30 PM, Mike Terry wrote:
> On 21/11/2020 02:45, olcott wrote:
>> void H_Hat(u32 P)
>> {
>> u32 Aborted = Halts(P, P);
>> if (Aborted)
>> HALT
>> else
>> HERE: goto HERE;
>> }
>>
>>
>> int main()
>> {
>> u32 P = (u32)H_Hat;
>> Halts(P, P);
>> HALT;
>> }
>>
>> (2) It is known that the above code is infinitely recursive if Halts()
>> acts like a UTM and simulates its input returning true if and only if
>> its input halts.
>
> Yes, we have infinite "recursive emulation".
>
>>
>> (3) On the basis of (1) and (2) It is known that a correct halt decider
>> must return false.
>
> There is no such thing as a "correct halt decider" for all inputs, but
> input (H_Hat,H_Hat) is non-halting, assuming your Halts() is as
> described. This is all baby stuff. [So the correct halting decision
> for the input is non-halting].
--
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-05-11 00:16 +0100 |
| Subject | Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] |
| Message-ID | <877dk65gd9.fsf@bsb.me.uk> |
| In reply to | #33274 |
olcott <NoOne@NoWhere.com> writes:
> On 5/10/2021 11:27 AM, Mike Terry wrote:
>> On 10/05/2021 16:25, olcott wrote:
>>> Ad hominem is a dishonest Jackass move used by people that insist on
>>> disagreement at the expense of truth.
>>>
>> I am stopping at your first major error. You do not understand what
>> ad-hominem means. I did not say your proof was incorrect because
>> you're incapable of abstract reasoning - I said that what you post
>> above IS NOT A PROOF OF ANYTHING. There is literally no proof for me
>> to review!
>
> And yet you already agreed that my current proof is correct:
You do a lot of lying about people agreeing with you. It can't just be
that you get honestly confused about what has been said because you'd
correct the lie as soon as the person pointed it out.
What can you possibly hope to gain by this dishonest move? I suppose it
just feels good to lie about people. It can't possibly help bolster
your case because no one who's been following these threads with even
half an eye open will know that your conclusions have no support from
anyone remotely competent.
Or maybe it just helps deflect the conversion, now that you are stuck in
a corner with nothing left to argue. You want false to be the correct
answer for some halting computations, but it isn't, and you have run out
of was to try to make it sound less daft.
> On 11/20/2020 9:30 PM, Mike Terry wrote:
>> On 21/11/2020 02:45, olcott wrote:
>>> void H_Hat(u32 P)
>>> {
>>> u32 Aborted = Halts(P, P);
>>> if (Aborted)
>>> HALT
>>> else
>>> HERE: goto HERE;
>>> }
>>>
>>>
>>> int main()
>>> {
>>> u32 P = (u32)H_Hat;
>>> Halts(P, P);
>>> HALT;
>>> }
>>>
>>> (2) It is known that the above code is infinitely recursive if Halts()
>>> acts like a UTM and simulates its input returning true if and only if
>>> its input halts.
NOTE: Halts acts like a UTM.
>> Yes, we have infinite "recursive emulation".
>>
>>> (3) On the basis of (1) and (2) It is known that a correct halt decider
>>> must return false.
--
Ben.
[toc] | [prev] | [next] | [standalone]
Page 4 of 5 — ← Prev page 1 2 3 [4] 5 Next page →
Back to top | Article view | comp.theory
csiph-web