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


Groups > comp.theory > #33180 > unrolled thread

Re: Halting problem undecidability and infinite recursion (PDF attached)

Started byMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
First post2021-05-09 20:01 +0100
Last post2021-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.


Contents

  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 →


#33273 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 16:33 +0000
SubjectRe: 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]


#33275 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 11:49 -0500
SubjectRe: 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]


#33277 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 16:58 +0000
SubjectRe: 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]


#33279 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 12:09 -0500
SubjectRe: 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]


#33251 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-10 11:54 +0100
SubjectRe: 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]


#33256 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 08:21 -0500
SubjectRe: 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]


#33268 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-10 17:00 +0100
SubjectRe: 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]


#33271 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 11:22 -0500
SubjectRe: 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]


#33294 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-10 23:59 +0100
SubjectRe: 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]


#33295 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 18:05 -0500
SubjectRe: 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]


#33301 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromJeff Barnett <jbb@notatt.com>
Date2021-05-10 17:33 -0600
SubjectRe: 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]


#33316 — Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-11 02:03 +0100
SubjectRe: 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]


#33223

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-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]


#33240 — Re: Halting problem undecidability and infinite recursion (PO=Deluded Dumbo)

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2021-05-10 04:03 +0100
SubjectRe: 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]


#33244 — Re: Halting problem undecidability and infinite recursion [ necessarily(P) ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 22:25 -0500
SubjectRe: 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]


#33263 — Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2021-05-10 16:18 +0100
SubjectRe: 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]


#33264 — Re: Halting problem undecidability and infinite recursion [ Necessarily correct ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 10:25 -0500
SubjectRe: 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]


#33272 — Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ]

FromMike Terry <news.dead.person.stones@darjeeling.plus.com>
Date2021-05-10 17:27 +0100
SubjectRe: 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]


#33274 — Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ]

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 11:37 -0500
SubjectRe: 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]


#33298 — Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ]

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-11 00:16 +0100
SubjectRe: 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