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 2 of 5 — ← Prev page 1 [2] 3 4 5  Next page →


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 00:25 +0000
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<20210509171609.914@kylheku.com>
In reply to#33210
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
> On 5/9/2021 7:07 PM, Richard Damon wrote:
>> On 5/9/21 7:38 PM, olcott wrote:
>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>> 
>>>> IF your statement is that the stopping of the simulation by the
>>>> simulator because it thinks the computation is non-halting does not show
>>>> that the computation is halting, I think we all agree to that an no one
>>>> has said any different. I think you just get so stuck into thinking
>>>> about simulations that when WE talk about actually runnning machines,
>>>> you still think about simulations.
>>>>
>>>>
>>>> Will you positively state that if we run that actual machine itself, and
>>>> it halts, that it is a Halting Computation? Lay to rest positively that
>>>> you would even consider a different definition?
>>>>
>>>
>>> **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.
>>>
>>>
>> 
>> BUT, do you agree that if when we run a machine itself, that if it
>> Halts, then it is a Halting Computation?
>
> When any computation only halts because it was aborted at some point 
> then this aborted computation <is not> a halting computation.
> H_Hat(H_Hat) only halts because it is aborted at some point.

That simply isn't true. Halts puts together a simulation, performs
it step by step while checking some condition and at some point it
stops doing that, and returns. It isn't aborted; it returns normally due
to its own decision.

Halts returns 0 to H_Hat, and then H_Hat bails of its own accord.

Nothing is aborted, just a simulation inside Halts.

Moreover, the abort of the simulation, or the conclusion drawn from it,
is itself incorrect.  Inside the simulation, H_Hat is also calling
Halts, and that Halts will return 0 if it is stepped far enough.
What is aborted is not a non-terminating calculation. Rather, a
terminating calculation is prematurely aborted.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

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


#33213 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 19:37 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<p5GdnTyPUfbWHQX9nZ2dnUU7-afNnZ2d@giganews.com>
In reply to#33211
On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>> On 5/9/21 7:38 PM, olcott wrote:
>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>
>>>>> IF your statement is that the stopping of the simulation by the
>>>>> simulator because it thinks the computation is non-halting does not show
>>>>> that the computation is halting, I think we all agree to that an no one
>>>>> has said any different. I think you just get so stuck into thinking
>>>>> about simulations that when WE talk about actually runnning machines,
>>>>> you still think about simulations.
>>>>>
>>>>>
>>>>> Will you positively state that if we run that actual machine itself, and
>>>>> it halts, that it is a Halting Computation? Lay to rest positively that
>>>>> you would even consider a different definition?
>>>>>
>>>>
>>>> **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.
>>>>
>>>>
>>>
>>> BUT, do you agree that if when we run a machine itself, that if it
>>> Halts, then it is a Halting Computation?
>>
>> When any computation only halts because it was aborted at some point
>> then this aborted computation <is not> a halting computation.
>> H_Hat(H_Hat) only halts because it is aborted at some point.
> 
> That simply isn't true. 

The more you continue to dodge this point the less honest you prove to be:

*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.



-- 
Copyright 2021 Pete Olcott

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

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


#33217 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-05-09 18:51 -0600
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<s7a028$9a0$2@dont-email.me>
In reply to#33213
On 2021-05-09 18:37, olcott wrote:
> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>
>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>> simulator because it thinks the computation is non-halting does 
>>>>>> not show
>>>>>> that the computation is halting, I think we all agree to that an 
>>>>>> no one
>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>> about simulations that when WE talk about actually runnning machines,
>>>>>> you still think about simulations.
>>>>>>
>>>>>>
>>>>>> Will you positively state that if we run that actual machine 
>>>>>> itself, and
>>>>>> it halts, that it is a Halting Computation? Lay to rest positively 
>>>>>> that
>>>>>> you would even consider a different definition?
>>>>>>
>>>>>
>>>>> **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.
>>>>>
>>>>>
>>>>
>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>> Halts, then it is a Halting Computation?
>>>
>>> When any computation only halts because it was aborted at some point
>>> then this aborted computation <is not> a halting computation.
>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>
>> That simply isn't true. 
> 
> The more you continue to dodge this point the less honest you prove to be:
> 
> *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.

First, 'impossibly incorrect' isn't meaningful English.

Second, you have claimed to have a 'non-halting behaviour pattern', but 
nowhere have you ever provided proof that this pattern is 'correct'. 
It's simply one of those things you've 'stipulated'.

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#33229 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 20:50 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<5-SdndS87-D3DAX9nZ2dnUU7-LnNnZ2d@giganews.com>
In reply to#33217
On 5/9/2021 7:51 PM, André G. Isaak wrote:
> On 2021-05-09 18:37, olcott wrote:
>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>
>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>> simulator because it thinks the computation is non-halting does 
>>>>>>> not show
>>>>>>> that the computation is halting, I think we all agree to that an 
>>>>>>> no one
>>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>> machines,
>>>>>>> you still think about simulations.
>>>>>>>
>>>>>>>
>>>>>>> Will you positively state that if we run that actual machine 
>>>>>>> itself, and
>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>> positively that
>>>>>>> you would even consider a different definition?
>>>>>>>
>>>>>>
>>>>>> **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.
>>>>>>
>>>>>>
>>>>>
>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>> Halts, then it is a Halting Computation?
>>>>
>>>> When any computation only halts because it was aborted at some point
>>>> then this aborted computation <is not> a halting computation.
>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>
>>> That simply isn't true. 
>>
>> The more you continue to dodge this point the less honest you prove to 
>> be:
>>
>> *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.
> 
> First, 'impossibly incorrect' isn't meaningful English.
> 

It is the necessarily(X) of modal logic.

> Second, you have claimed to have a 'non-halting behaviour pattern', but 
> nowhere have you ever provided proof that this pattern is 'correct'. 
> It's simply one of those things you've 'stipulated'.
> 
> André
> 

You found an error in my infinite loop detection and I credited you with 
this in my paper. So far no one has found any error in this:

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.

When we assume that the above is correct and we can see that the 
behavior of H_Hat() matches the above criteria then it necessarily 
follows that Halts(H_Hat, H_Hat) == 0 is correct.

-- 
Copyright 2021 Pete Olcott

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

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


#33231 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-05-09 20:33 -0600
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<s7a62j$cjq$1@dont-email.me>
In reply to#33229
On 2021-05-09 19:50, olcott wrote:
> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>> On 2021-05-09 18:37, olcott wrote:
>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>
>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>> simulator because it thinks the computation is non-halting does 
>>>>>>>> not show
>>>>>>>> that the computation is halting, I think we all agree to that an 
>>>>>>>> no one
>>>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>>> machines,
>>>>>>>> you still think about simulations.
>>>>>>>>
>>>>>>>>
>>>>>>>> Will you positively state that if we run that actual machine 
>>>>>>>> itself, and
>>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>>> positively that
>>>>>>>> you would even consider a different definition?
>>>>>>>>
>>>>>>>
>>>>>>> **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.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>> Halts, then it is a Halting Computation?
>>>>>
>>>>> When any computation only halts because it was aborted at some point
>>>>> then this aborted computation <is not> a halting computation.
>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>
>>>> That simply isn't true. 
>>>
>>> The more you continue to dodge this point the less honest you prove 
>>> to be:
>>>
>>> *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.
>>
>> First, 'impossibly incorrect' isn't meaningful English.
>>
> 
> It is the necessarily(X) of modal logic.

Not in anyone else's usage. If you can find someone other than yourself 
who uses it this way, please let us know.

This doesn't match with normal English usage. Cf. 'impossibly strong' 
(meaning extremely strong) 'impossibly loud' (unbelievably loud) etc.

>> Second, you have claimed to have a 'non-halting behaviour pattern', 
>> but nowhere have you ever provided proof that this pattern is 
>> 'correct'. It's simply one of those things you've 'stipulated'.
>>
>> André
>>
> 
> You found an error in my infinite loop detection and I credited you with 
> this in my paper. So far no one has found any error in this:
> 
> 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.
> 
> When we assume that the above is correct and we can see that the 
> behavior of H_Hat() matches the above criteria then it necessarily 
> follows that Halts(H_Hat, H_Hat) == 0 is correct.

It's not incumbent on others to find flaws with your pattern. It's 
incombent on *you* to prove that this pattern actually means what you 
say it means and you have not done so.

Does this following meet your criterion for 'infinite recursion'?

void foo(void) {
     foo2();
     foo();
}

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#33233 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 21:43 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<gP2dnX1dYphKAAX9nZ2dnUU7-L3NnZ2d@giganews.com>
In reply to#33231
On 5/9/2021 9:33 PM, André G. Isaak wrote:
> On 2021-05-09 19:50, olcott wrote:
>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>> On 2021-05-09 18:37, olcott wrote:
>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>>> simulator because it thinks the computation is non-halting does 
>>>>>>>>> not show
>>>>>>>>> that the computation is halting, I think we all agree to that 
>>>>>>>>> an no one
>>>>>>>>> has said any different. I think you just get so stuck into 
>>>>>>>>> thinking
>>>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>>>> machines,
>>>>>>>>> you still think about simulations.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Will you positively state that if we run that actual machine 
>>>>>>>>> itself, and
>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>>>> positively that
>>>>>>>>> you would even consider a different definition?
>>>>>>>>>
>>>>>>>>
>>>>>>>> **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.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>>> Halts, then it is a Halting Computation?
>>>>>>
>>>>>> When any computation only halts because it was aborted at some point
>>>>>> then this aborted computation <is not> a halting computation.
>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>
>>>>> That simply isn't true. 
>>>>
>>>> The more you continue to dodge this point the less honest you prove 
>>>> to be:
>>>>
>>>> *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.
>>>
>>> First, 'impossibly incorrect' isn't meaningful English.
>>>
>>
>> It is the necessarily(X) of modal logic.
> 
> Not in anyone else's usage. If you can find someone other than yourself 
> who uses it this way, please let us know.
> 
> This doesn't match with normal English usage. Cf. 'impossibly strong' 
> (meaning extremely strong) 'impossibly loud' (unbelievably loud) etc.
> 
>>> Second, you have claimed to have a 'non-halting behaviour pattern', 
>>> but nowhere have you ever provided proof that this pattern is 
>>> 'correct'. It's simply one of those things you've 'stipulated'.
>>>
>>> André
>>>
>>
>> You found an error in my infinite loop detection and I credited you 
>> with this in my paper. So far no one has found any error in this:
>>
>> 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.
>>
>> When we assume that the above is correct and we can see that the 
>> behavior of H_Hat() matches the above criteria then it necessarily 
>> follows that Halts(H_Hat, H_Hat) == 0 is correct.
> 
> It's not incumbent on others to find flaws with your pattern. It's 
> incombent on *you* to prove that this pattern actually means what you 
> say it means and you have not done so.
> 
> Does this following meet your criterion for 'infinite recursion'?
> 
> void foo(void) {
>      foo2();
>      foo();
> }
> 
> André
> 

I can't tell it might not compile because of a missing foo2() body.

-- 
Copyright 2021 Pete Olcott

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

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


#33242 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-05-09 21:06 -0600
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<s7a7v9$5sh$1@dont-email.me>
In reply to#33233
On 2021-05-09 20:43, olcott wrote:
> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>> On 2021-05-09 19:50, olcott wrote:
>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>> On 2021-05-09 18:37, olcott wrote:
>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>>>> simulator because it thinks the computation is non-halting 
>>>>>>>>>> does not show
>>>>>>>>>> that the computation is halting, I think we all agree to that 
>>>>>>>>>> an no one
>>>>>>>>>> has said any different. I think you just get so stuck into 
>>>>>>>>>> thinking
>>>>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>>>>> machines,
>>>>>>>>>> you still think about simulations.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Will you positively state that if we run that actual machine 
>>>>>>>>>> itself, and
>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>>>>> positively that
>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> **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.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>
>>>>>>> When any computation only halts because it was aborted at some point
>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>
>>>>>> That simply isn't true. 
>>>>>
>>>>> The more you continue to dodge this point the less honest you prove 
>>>>> to be:
>>>>>
>>>>> *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.
>>>>
>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>
>>>
>>> It is the necessarily(X) of modal logic.
>>
>> Not in anyone else's usage. If you can find someone other than 
>> yourself who uses it this way, please let us know.
>>
>> This doesn't match with normal English usage. Cf. 'impossibly strong' 
>> (meaning extremely strong) 'impossibly loud' (unbelievably loud) etc.
>>
>>>> Second, you have claimed to have a 'non-halting behaviour pattern', 
>>>> but nowhere have you ever provided proof that this pattern is 
>>>> 'correct'. It's simply one of those things you've 'stipulated'.
>>>>
>>>> André
>>>>
>>>
>>> You found an error in my infinite loop detection and I credited you 
>>> with this in my paper. So far no one has found any error in this:
>>>
>>> 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.
>>>
>>> When we assume that the above is correct and we can see that the 
>>> behavior of H_Hat() matches the above criteria then it necessarily 
>>> follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>
>> It's not incumbent on others to find flaws with your pattern. It's 
>> incombent on *you* to prove that this pattern actually means what you 
>> say it means and you have not done so.
>>
>> Does this following meet your criterion for 'infinite recursion'?
>>
>> void foo(void) {
>>      foo2();
>>      foo();
>> }
>>
>> André
>>
> 
> I can't tell it might not compile because of a missing foo2() body.

But that was my entire point. You can't know whether the above is 
infinitely recursive or not without knowing how foo2() is defined. Your 
'pattern matcher' needs to look *inside* all calls made. If foo2() 
simply returns, then the above is infinitely recursive. If foo2() enters 
an infinite loop, then the above isn't finite, but it also isn't 
infinitely recursive. And if foo2() throws an exception, the above will 
not be infinitely recursive, it will be finite.

However, in all your traces, you selectively skip over certain function 
calls as if it is somehow possible to make an assessment without 
considering what goes on inside every function call made from the code 
you are looking at. That is your fatal mistake (well, one of many).

André

-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#33245 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 22:36 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<pNCdnS0meYOxNwX9nZ2dnUU7-eXNnZ2d@giganews.com>
In reply to#33242
On 5/9/2021 10:06 PM, André G. Isaak wrote:
> On 2021-05-09 20:43, olcott wrote:
>> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>>> On 2021-05-09 19:50, olcott wrote:
>>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>>> On 2021-05-09 18:37, olcott wrote:
>>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>>>>> simulator because it thinks the computation is non-halting 
>>>>>>>>>>> does not show
>>>>>>>>>>> that the computation is halting, I think we all agree to that 
>>>>>>>>>>> an no one
>>>>>>>>>>> has said any different. I think you just get so stuck into 
>>>>>>>>>>> thinking
>>>>>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>>>>>> machines,
>>>>>>>>>>> you still think about simulations.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Will you positively state that if we run that actual machine 
>>>>>>>>>>> itself, and
>>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>>>>>> positively that
>>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> **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.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>>
>>>>>>>> When any computation only halts because it was aborted at some 
>>>>>>>> point
>>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>
>>>>>>> That simply isn't true. 
>>>>>>
>>>>>> The more you continue to dodge this point the less honest you 
>>>>>> prove to be:
>>>>>>
>>>>>> *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.
>>>>>
>>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>>
>>>>
>>>> It is the necessarily(X) of modal logic.
>>>
>>> Not in anyone else's usage. If you can find someone other than 
>>> yourself who uses it this way, please let us know.
>>>
>>> This doesn't match with normal English usage. Cf. 'impossibly strong' 
>>> (meaning extremely strong) 'impossibly loud' (unbelievably loud) etc.
>>>
>>>>> Second, you have claimed to have a 'non-halting behaviour pattern', 
>>>>> but nowhere have you ever provided proof that this pattern is 
>>>>> 'correct'. It's simply one of those things you've 'stipulated'.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> You found an error in my infinite loop detection and I credited you 
>>>> with this in my paper. So far no one has found any error in this:
>>>>
>>>> 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.
>>>>
>>>> When we assume that the above is correct and we can see that the 
>>>> behavior of H_Hat() matches the above criteria then it necessarily 
>>>> follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>>
>>> It's not incumbent on others to find flaws with your pattern. It's 
>>> incombent on *you* to prove that this pattern actually means what you 
>>> say it means and you have not done so.
>>>
>>> Does this following meet your criterion for 'infinite recursion'?
>>>
>>> void foo(void) {
>>>      foo2();
>>>      foo();
>>> }
>>>
>>> André
>>>
>>
>> I can't tell it might not compile because of a missing foo2() body.
> 
> But that was my entire point. You can't know whether the above is 
> infinitely recursive or not without knowing how foo2() is defined. 

Do you really think that an at least partial halt decider must have 
psychic ability?

> Your 
> 'pattern matcher' needs to look *inside* all calls made. If foo2() 
> simply returns, then the above is infinitely recursive. 

Axiom(4)  with no function call returns from X()
along with the other three axioms <is> sufficient.

Axiom(4) is known to always be satisfied in the case of infinitely 
nested simulation because no simulator ever returns to the input that it 
is simulating.

> If foo2() enters 
> an infinite loop, then the above isn't finite, but it also isn't 
> infinitely recursive. And if foo2() throws an exception, the above will 
> not be infinitely recursive, it will be finite.
> 
> However, in all your traces, you selectively skip over certain function 
> calls as if it is somehow possible to make an assessment without 
> considering what goes on inside every function call made from the code 
> you are looking at. That is your fatal mistake (well, one of many).
> 
> André
> 

I only need to be able to correctly specify a very small number of cases 
to prove that H_Hat() matches an infinitely nested simulation pattern.
As long as this pattern never matches any finite computation, then the 
pattern is sufficient for my purposes.

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

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




-- 
Copyright 2021 Pete Olcott

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

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


#33246 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-05-09 22:31 -0600
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<s7acus$tqv$1@dont-email.me>
In reply to#33245
On 2021-05-09 21:36, olcott wrote:
> On 5/9/2021 10:06 PM, André G. Isaak wrote:
>> On 2021-05-09 20:43, olcott wrote:
>>> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>>>> On 2021-05-09 19:50, olcott wrote:
>>>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>>>> On 2021-05-09 18:37, olcott wrote:
>>>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>>>>>> simulator because it thinks the computation is non-halting 
>>>>>>>>>>>> does not show
>>>>>>>>>>>> that the computation is halting, I think we all agree to 
>>>>>>>>>>>> that an no one
>>>>>>>>>>>> has said any different. I think you just get so stuck into 
>>>>>>>>>>>> thinking
>>>>>>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>>>>>>> machines,
>>>>>>>>>>>> you still think about simulations.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Will you positively state that if we run that actual machine 
>>>>>>>>>>>> itself, and
>>>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>>>>>>> positively that
>>>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> **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.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> BUT, do you agree that if when we run a machine itself, that 
>>>>>>>>>> if it
>>>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>>>
>>>>>>>>> When any computation only halts because it was aborted at some 
>>>>>>>>> point
>>>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>>
>>>>>>>> That simply isn't true. 
>>>>>>>
>>>>>>> The more you continue to dodge this point the less honest you 
>>>>>>> prove to be:
>>>>>>>
>>>>>>> *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.
>>>>>>
>>>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>>>
>>>>>
>>>>> It is the necessarily(X) of modal logic.
>>>>
>>>> Not in anyone else's usage. If you can find someone other than 
>>>> yourself who uses it this way, please let us know.
>>>>
>>>> This doesn't match with normal English usage. Cf. 'impossibly 
>>>> strong' (meaning extremely strong) 'impossibly loud' (unbelievably 
>>>> loud) etc.
>>>>
>>>>>> Second, you have claimed to have a 'non-halting behaviour 
>>>>>> pattern', but nowhere have you ever provided proof that this 
>>>>>> pattern is 'correct'. It's simply one of those things you've 
>>>>>> 'stipulated'.
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> You found an error in my infinite loop detection and I credited you 
>>>>> with this in my paper. So far no one has found any error in this:
>>>>>
>>>>> 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.
>>>>>
>>>>> When we assume that the above is correct and we can see that the 
>>>>> behavior of H_Hat() matches the above criteria then it necessarily 
>>>>> follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>>>
>>>> It's not incumbent on others to find flaws with your pattern. It's 
>>>> incombent on *you* to prove that this pattern actually means what 
>>>> you say it means and you have not done so.
>>>>
>>>> Does this following meet your criterion for 'infinite recursion'?
>>>>
>>>> void foo(void) {
>>>>      foo2();
>>>>      foo();
>>>> }
>>>>
>>>> André
>>>>
>>>
>>> I can't tell it might not compile because of a missing foo2() body.
>>
>> But that was my entire point. You can't know whether the above is 
>> infinitely recursive or not without knowing how foo2() is defined. 
> 
> Do you really think that an at least partial halt decider must have 
> psychic ability?

Did I claim that it did?

>> Your 'pattern matcher' needs to look *inside* all calls made. If 
>> foo2() simply returns, then the above is infinitely recursive. 
> 
> Axiom(4)  with no function call returns from X()
> along with the other three axioms <is> sufficient.
> 
> Axiom(4) is known to always be satisfied in the case of infinitely 
> nested simulation because no simulator ever returns to the input that it 
> is simulating.

But your 'halts' isn't a simulator. It is a *modified* simulator, one 
which stops simulating under certain circumstances. So you won't have 
infinitely nested simulations.

>> If foo2() enters an infinite loop, then the above isn't finite, but it 
>> also isn't infinitely recursive. And if foo2() throws an exception, 
>> the above will not be infinitely recursive, it will be finite.
>>
>> However, in all your traces, you selectively skip over certain 
>> function calls as if it is somehow possible to make an assessment 
>> without considering what goes on inside every function call made from 
>> the code you are looking at. That is your fatal mistake (well, one of 
>> many).
>>
>> André
>>
> 
> I only need to be able to correctly specify a very small number of cases 
> to prove that H_Hat() matches an infinitely nested simulation pattern.
> As long as this pattern never matches any finite computation, then the 
> pattern is sufficient for my purposes.
> 
> void H_Hat(u32 P)
> {
>    u32 Input_Halts = Halts(P, P);
>    if (Input_Halts)
>      HERE: goto HERE;
> }

But this is no different from the example I gave where you couldn't 
assess it without knowing what occurs inside foo2(). You've defined 
H_Hat but you've never actually shown us what occurs inside Halts() (or 
you've defined it in terms of other undefined functions).

André

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


-- 
To email remove 'invalid' & replace 'gm' with well known Google mail 
service.

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


#33247 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 23:41 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<z4mdneHlX-wbJAX9nZ2dnUU7-bPNnZ2d@giganews.com>
In reply to#33246
On 5/9/2021 11:31 PM, André G. Isaak wrote:
> On 2021-05-09 21:36, olcott wrote:
>> On 5/9/2021 10:06 PM, André G. Isaak wrote:
>>> On 2021-05-09 20:43, olcott wrote:
>>>> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>>>>> On 2021-05-09 19:50, olcott wrote:
>>>>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>>>>> On 2021-05-09 18:37, olcott wrote:
>>>>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>>>> IF your statement is that the stopping of the simulation by 
>>>>>>>>>>>>> the
>>>>>>>>>>>>> simulator because it thinks the computation is non-halting 
>>>>>>>>>>>>> does not show
>>>>>>>>>>>>> that the computation is halting, I think we all agree to 
>>>>>>>>>>>>> that an no one
>>>>>>>>>>>>> has said any different. I think you just get so stuck into 
>>>>>>>>>>>>> thinking
>>>>>>>>>>>>> about simulations that when WE talk about actually runnning 
>>>>>>>>>>>>> machines,
>>>>>>>>>>>>> you still think about simulations.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Will you positively state that if we run that actual 
>>>>>>>>>>>>> machine itself, and
>>>>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest 
>>>>>>>>>>>>> positively that
>>>>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> **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.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> BUT, do you agree that if when we run a machine itself, that 
>>>>>>>>>>> if it
>>>>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>>>>
>>>>>>>>>> When any computation only halts because it was aborted at some 
>>>>>>>>>> point
>>>>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>>>
>>>>>>>>> That simply isn't true. 
>>>>>>>>
>>>>>>>> The more you continue to dodge this point the less honest you 
>>>>>>>> prove to be:
>>>>>>>>
>>>>>>>> *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.
>>>>>>>
>>>>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>>>>
>>>>>>
>>>>>> It is the necessarily(X) of modal logic.
>>>>>
>>>>> Not in anyone else's usage. If you can find someone other than 
>>>>> yourself who uses it this way, please let us know.
>>>>>
>>>>> This doesn't match with normal English usage. Cf. 'impossibly 
>>>>> strong' (meaning extremely strong) 'impossibly loud' (unbelievably 
>>>>> loud) etc.
>>>>>
>>>>>>> Second, you have claimed to have a 'non-halting behaviour 
>>>>>>> pattern', but nowhere have you ever provided proof that this 
>>>>>>> pattern is 'correct'. It's simply one of those things you've 
>>>>>>> 'stipulated'.
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> You found an error in my infinite loop detection and I credited 
>>>>>> you with this in my paper. So far no one has found any error in this:
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>> When we assume that the above is correct and we can see that the 
>>>>>> behavior of H_Hat() matches the above criteria then it necessarily 
>>>>>> follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>>>>
>>>>> It's not incumbent on others to find flaws with your pattern. It's 
>>>>> incombent on *you* to prove that this pattern actually means what 
>>>>> you say it means and you have not done so.
>>>>>
>>>>> Does this following meet your criterion for 'infinite recursion'?
>>>>>
>>>>> void foo(void) {
>>>>>      foo2();
>>>>>      foo();
>>>>> }
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I can't tell it might not compile because of a missing foo2() body.
>>>
>>> But that was my entire point. You can't know whether the above is 
>>> infinitely recursive or not without knowing how foo2() is defined. 
>>
>> Do you really think that an at least partial halt decider must have 
>> psychic ability?
> 
> Did I claim that it did?
> 
>>> Your 'pattern matcher' needs to look *inside* all calls made. If 
>>> foo2() simply returns, then the above is infinitely recursive. 
>>
>> Axiom(4)  with no function call returns from X()
>> along with the other three axioms <is> sufficient.
>>
>> Axiom(4) is known to always be satisfied in the case of infinitely 
>> nested simulation because no simulator ever returns to the input that 
>> it is simulating.
> 
> But your 'halts' isn't a simulator. It is a *modified* simulator, one 
> which stops simulating under certain circumstances. So you won't have 
> infinitely nested simulations.
> 
>>> If foo2() enters an infinite loop, then the above isn't finite, but 
>>> it also isn't infinitely recursive. And if foo2() throws an 
>>> exception, the above will not be infinitely recursive, it will be 
>>> finite.
>>>
>>> However, in all your traces, you selectively skip over certain 
>>> function calls as if it is somehow possible to make an assessment 
>>> without considering what goes on inside every function call made from 
>>> the code you are looking at. That is your fatal mistake (well, one of 
>>> many).
>>>
>>> André
>>>
>>
>> I only need to be able to correctly specify a very small number of 
>> cases to prove that H_Hat() matches an infinitely nested simulation 
>> pattern.
>> As long as this pattern never matches any finite computation, then the 
>> pattern is sufficient for my purposes.
>>
>> void H_Hat(u32 P)
>> {
>>    u32 Input_Halts = Halts(P, P);
>>    if (Input_Halts)
>>      HERE: goto HERE;
>> }
> 
> But this is no different from the example I gave where you couldn't 
> assess it without knowing what occurs inside foo2(). You've defined 
> H_Hat but you've never actually shown us what occurs inside Halts() (or 
> you've defined it in terms of other undefined functions).
> 

I know that Halts() never returns to its input and that it all the need 
be known to match the pattern.


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


-- 
Copyright 2021 Pete Olcott

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

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


#33252 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-10 08:17 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<Gv9mI.324492$2A5.297680@fx45.iad>
In reply to#33247
On 5/10/21 12:41 AM, olcott wrote:
> On 5/9/2021 11:31 PM, André G. Isaak wrote:
>> On 2021-05-09 21:36, olcott wrote:
>>> On 5/9/2021 10:06 PM, André G. Isaak wrote:
>>>> On 2021-05-09 20:43, olcott wrote:
>>>>> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>>>>>> On 2021-05-09 19:50, olcott wrote:
>>>>>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>>>>>> On 2021-05-09 18:37, olcott wrote:
>>>>>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>>> IF your statement is that the stopping of the simulation
>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>> simulator because it thinks the computation is non-halting
>>>>>>>>>>>>>> does not show
>>>>>>>>>>>>>> that the computation is halting, I think we all agree to
>>>>>>>>>>>>>> that an no one
>>>>>>>>>>>>>> has said any different. I think you just get so stuck into
>>>>>>>>>>>>>> thinking
>>>>>>>>>>>>>> about simulations that when WE talk about actually
>>>>>>>>>>>>>> runnning machines,
>>>>>>>>>>>>>> you still think about simulations.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Will you positively state that if we run that actual
>>>>>>>>>>>>>> machine itself, and
>>>>>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest
>>>>>>>>>>>>>> positively that
>>>>>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> **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.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> BUT, do you agree that if when we run a machine itself, that
>>>>>>>>>>>> if it
>>>>>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>>>>>
>>>>>>>>>>> When any computation only halts because it was aborted at
>>>>>>>>>>> some point
>>>>>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>>>>
>>>>>>>>>> That simply isn't true. 
>>>>>>>>>
>>>>>>>>> The more you continue to dodge this point the less honest you
>>>>>>>>> prove to be:
>>>>>>>>>
>>>>>>>>> *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.
>>>>>>>>
>>>>>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>>>>>
>>>>>>>
>>>>>>> It is the necessarily(X) of modal logic.
>>>>>>
>>>>>> Not in anyone else's usage. If you can find someone other than
>>>>>> yourself who uses it this way, please let us know.
>>>>>>
>>>>>> This doesn't match with normal English usage. Cf. 'impossibly
>>>>>> strong' (meaning extremely strong) 'impossibly loud' (unbelievably
>>>>>> loud) etc.
>>>>>>
>>>>>>>> Second, you have claimed to have a 'non-halting behaviour
>>>>>>>> pattern', but nowhere have you ever provided proof that this
>>>>>>>> pattern is 'correct'. It's simply one of those things you've
>>>>>>>> 'stipulated'.
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> You found an error in my infinite loop detection and I credited
>>>>>>> you with this in my paper. So far no one has found any error in
>>>>>>> this:
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>>> When we assume that the above is correct and we can see that the
>>>>>>> behavior of H_Hat() matches the above criteria then it
>>>>>>> necessarily follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>>>>>
>>>>>> It's not incumbent on others to find flaws with your pattern. It's
>>>>>> incombent on *you* to prove that this pattern actually means what
>>>>>> you say it means and you have not done so.
>>>>>>
>>>>>> Does this following meet your criterion for 'infinite recursion'?
>>>>>>
>>>>>> void foo(void) {
>>>>>>      foo2();
>>>>>>      foo();
>>>>>> }
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> I can't tell it might not compile because of a missing foo2() body.
>>>>
>>>> But that was my entire point. You can't know whether the above is
>>>> infinitely recursive or not without knowing how foo2() is defined. 
>>>
>>> Do you really think that an at least partial halt decider must have
>>> psychic ability?
>>
>> Did I claim that it did?
>>
>>>> Your 'pattern matcher' needs to look *inside* all calls made. If
>>>> foo2() simply returns, then the above is infinitely recursive. 
>>>
>>> Axiom(4)  with no function call returns from X()
>>> along with the other three axioms <is> sufficient.
>>>
>>> Axiom(4) is known to always be satisfied in the case of infinitely
>>> nested simulation because no simulator ever returns to the input that
>>> it is simulating.
>>
>> But your 'halts' isn't a simulator. It is a *modified* simulator, one
>> which stops simulating under certain circumstances. So you won't have
>> infinitely nested simulations.
>>
>>>> If foo2() enters an infinite loop, then the above isn't finite, but
>>>> it also isn't infinitely recursive. And if foo2() throws an
>>>> exception, the above will not be infinitely recursive, it will be
>>>> finite.
>>>>
>>>> However, in all your traces, you selectively skip over certain
>>>> function calls as if it is somehow possible to make an assessment
>>>> without considering what goes on inside every function call made
>>>> from the code you are looking at. That is your fatal mistake (well,
>>>> one of many).
>>>>
>>>> André
>>>>
>>>
>>> I only need to be able to correctly specify a very small number of
>>> cases to prove that H_Hat() matches an infinitely nested simulation
>>> pattern.
>>> As long as this pattern never matches any finite computation, then
>>> the pattern is sufficient for my purposes.
>>>
>>> void H_Hat(u32 P)
>>> {
>>>    u32 Input_Halts = Halts(P, P);
>>>    if (Input_Halts)
>>>      HERE: goto HERE;
>>> }
>>
>> But this is no different from the example I gave where you couldn't
>> assess it without knowing what occurs inside foo2(). You've defined
>> H_Hat but you've never actually shown us what occurs inside Halts()
>> (or you've defined it in terms of other undefined functions).
>>
> 
> I know that Halts() never returns to its input and that it all the need
> be known to match the pattern.
> 

But it better return to its caller, even if its caller is another copy
of the machine it is simulating.

You keep making that nonsense sectence as if it allows you to get out of
giving the answer to the H_Hat that calls it with Halts(H_Hat, H_Hat).

It doesnt.

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

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


#33257 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 08:32 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<J8idnbDLpbRlqAT9nZ2dnUU7-TvNnZ2d@giganews.com>
In reply to#33252
On 5/10/2021 7:17 AM, Richard Damon wrote:
> On 5/10/21 12:41 AM, olcott wrote:
>> On 5/9/2021 11:31 PM, André G. Isaak wrote:
>>> On 2021-05-09 21:36, olcott wrote:
>>>> On 5/9/2021 10:06 PM, André G. Isaak wrote:
>>>>> On 2021-05-09 20:43, olcott wrote:
>>>>>> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>>>>>>> On 2021-05-09 19:50, olcott wrote:
>>>>>>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-05-09 18:37, olcott wrote:
>>>>>>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>>> IF your statement is that the stopping of the simulation
>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>> simulator because it thinks the computation is non-halting
>>>>>>>>>>>>>>> does not show
>>>>>>>>>>>>>>> that the computation is halting, I think we all agree to
>>>>>>>>>>>>>>> that an no one
>>>>>>>>>>>>>>> has said any different. I think you just get so stuck into
>>>>>>>>>>>>>>> thinking
>>>>>>>>>>>>>>> about simulations that when WE talk about actually
>>>>>>>>>>>>>>> runnning machines,
>>>>>>>>>>>>>>> you still think about simulations.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Will you positively state that if we run that actual
>>>>>>>>>>>>>>> machine itself, and
>>>>>>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest
>>>>>>>>>>>>>>> positively that
>>>>>>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> **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.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> BUT, do you agree that if when we run a machine itself, that
>>>>>>>>>>>>> if it
>>>>>>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>>>>>>
>>>>>>>>>>>> When any computation only halts because it was aborted at
>>>>>>>>>>>> some point
>>>>>>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>>>>>
>>>>>>>>>>> That simply isn't true.
>>>>>>>>>>
>>>>>>>>>> The more you continue to dodge this point the less honest you
>>>>>>>>>> prove to be:
>>>>>>>>>>
>>>>>>>>>> *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.
>>>>>>>>>
>>>>>>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is the necessarily(X) of modal logic.
>>>>>>>
>>>>>>> Not in anyone else's usage. If you can find someone other than
>>>>>>> yourself who uses it this way, please let us know.
>>>>>>>
>>>>>>> This doesn't match with normal English usage. Cf. 'impossibly
>>>>>>> strong' (meaning extremely strong) 'impossibly loud' (unbelievably
>>>>>>> loud) etc.
>>>>>>>
>>>>>>>>> Second, you have claimed to have a 'non-halting behaviour
>>>>>>>>> pattern', but nowhere have you ever provided proof that this
>>>>>>>>> pattern is 'correct'. It's simply one of those things you've
>>>>>>>>> 'stipulated'.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> You found an error in my infinite loop detection and I credited
>>>>>>>> you with this in my paper. So far no one has found any error in
>>>>>>>> this:
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>
>>>>>>>> When we assume that the above is correct and we can see that the
>>>>>>>> behavior of H_Hat() matches the above criteria then it
>>>>>>>> necessarily follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>>>>>>
>>>>>>> It's not incumbent on others to find flaws with your pattern. It's
>>>>>>> incombent on *you* to prove that this pattern actually means what
>>>>>>> you say it means and you have not done so.
>>>>>>>
>>>>>>> Does this following meet your criterion for 'infinite recursion'?
>>>>>>>
>>>>>>> void foo(void) {
>>>>>>>       foo2();
>>>>>>>       foo();
>>>>>>> }
>>>>>>>
>>>>>>> André
>>>>>>>
>>>>>>
>>>>>> I can't tell it might not compile because of a missing foo2() body.
>>>>>
>>>>> But that was my entire point. You can't know whether the above is
>>>>> infinitely recursive or not without knowing how foo2() is defined.
>>>>
>>>> Do you really think that an at least partial halt decider must have
>>>> psychic ability?
>>>
>>> Did I claim that it did?
>>>
>>>>> Your 'pattern matcher' needs to look *inside* all calls made. If
>>>>> foo2() simply returns, then the above is infinitely recursive.
>>>>
>>>> Axiom(4)  with no function call returns from X()
>>>> along with the other three axioms <is> sufficient.
>>>>
>>>> Axiom(4) is known to always be satisfied in the case of infinitely
>>>> nested simulation because no simulator ever returns to the input that
>>>> it is simulating.
>>>
>>> But your 'halts' isn't a simulator. It is a *modified* simulator, one
>>> which stops simulating under certain circumstances. So you won't have
>>> infinitely nested simulations.
>>>
>>>>> If foo2() enters an infinite loop, then the above isn't finite, but
>>>>> it also isn't infinitely recursive. And if foo2() throws an
>>>>> exception, the above will not be infinitely recursive, it will be
>>>>> finite.
>>>>>
>>>>> However, in all your traces, you selectively skip over certain
>>>>> function calls as if it is somehow possible to make an assessment
>>>>> without considering what goes on inside every function call made
>>>>> from the code you are looking at. That is your fatal mistake (well,
>>>>> one of many).
>>>>>
>>>>> André
>>>>>
>>>>
>>>> I only need to be able to correctly specify a very small number of
>>>> cases to prove that H_Hat() matches an infinitely nested simulation
>>>> pattern.
>>>> As long as this pattern never matches any finite computation, then
>>>> the pattern is sufficient for my purposes.
>>>>
>>>> void H_Hat(u32 P)
>>>> {
>>>>     u32 Input_Halts = Halts(P, P);
>>>>     if (Input_Halts)
>>>>       HERE: goto HERE;
>>>> }
>>>
>>> But this is no different from the example I gave where you couldn't
>>> assess it without knowing what occurs inside foo2(). You've defined
>>> H_Hat but you've never actually shown us what occurs inside Halts()
>>> (or you've defined it in terms of other undefined functions).
>>>
>>
>> I know that Halts() never returns to its input and that it all the need
>> be known to match the pattern.
>>
> 
> But it better return to its caller, even if its caller is another copy
> of the machine it is simulating.
> 

Only the invocation of Halts() must return a value to its caller.
Halts() cannot possibly return to any input that it is simulating.

When Halts() is called in infinitely nested simulation none of the 
nested simulations of Halts() ever return to their caller.

It is generally the case (basic software engineering) that every 
function called in infinite recursion or infinitely nested simulation 
never returns to its caller.

> You keep making that nonsense sectence as if it allows you to get out of
> giving the answer to the H_Hat that calls it with Halts(H_Hat, H_Hat).
> 
> It doesnt.


-- 
Copyright 2021 Pete Olcott

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

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


#33307 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-10 19:46 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<_AjmI.585554$%W6.311060@fx44.iad>
In reply to#33257
On 5/10/21 9:32 AM, olcott wrote:
> On 5/10/2021 7:17 AM, Richard Damon wrote:
>> On 5/10/21 12:41 AM, olcott wrote:
>>> On 5/9/2021 11:31 PM, André G. Isaak wrote:
>>>> On 2021-05-09 21:36, olcott wrote:
>>>>> On 5/9/2021 10:06 PM, André G. Isaak wrote:
>>>>>> On 2021-05-09 20:43, olcott wrote:
>>>>>>> On 5/9/2021 9:33 PM, André G. Isaak wrote:
>>>>>>>> On 2021-05-09 19:50, olcott wrote:
>>>>>>>>> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>>>>>>>>>> On 2021-05-09 18:37, olcott wrote:
>>>>>>>>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>>>>>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> IF your statement is that the stopping of the simulation
>>>>>>>>>>>>>>>> by the
>>>>>>>>>>>>>>>> simulator because it thinks the computation is non-halting
>>>>>>>>>>>>>>>> does not show
>>>>>>>>>>>>>>>> that the computation is halting, I think we all agree to
>>>>>>>>>>>>>>>> that an no one
>>>>>>>>>>>>>>>> has said any different. I think you just get so stuck into
>>>>>>>>>>>>>>>> thinking
>>>>>>>>>>>>>>>> about simulations that when WE talk about actually
>>>>>>>>>>>>>>>> runnning machines,
>>>>>>>>>>>>>>>> you still think about simulations.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Will you positively state that if we run that actual
>>>>>>>>>>>>>>>> machine itself, and
>>>>>>>>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest
>>>>>>>>>>>>>>>> positively that
>>>>>>>>>>>>>>>> you would even consider a different definition?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> **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.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> BUT, do you agree that if when we run a machine itself, that
>>>>>>>>>>>>>> if it
>>>>>>>>>>>>>> Halts, then it is a Halting Computation?
>>>>>>>>>>>>>
>>>>>>>>>>>>> When any computation only halts because it was aborted at
>>>>>>>>>>>>> some point
>>>>>>>>>>>>> then this aborted computation <is not> a halting computation.
>>>>>>>>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>>>>>>>>
>>>>>>>>>>>> That simply isn't true.
>>>>>>>>>>>
>>>>>>>>>>> The more you continue to dodge this point the less honest you
>>>>>>>>>>> prove to be:
>>>>>>>>>>>
>>>>>>>>>>> *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.
>>>>>>>>>>
>>>>>>>>>> First, 'impossibly incorrect' isn't meaningful English.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is the necessarily(X) of modal logic.
>>>>>>>>
>>>>>>>> Not in anyone else's usage. If you can find someone other than
>>>>>>>> yourself who uses it this way, please let us know.
>>>>>>>>
>>>>>>>> This doesn't match with normal English usage. Cf. 'impossibly
>>>>>>>> strong' (meaning extremely strong) 'impossibly loud' (unbelievably
>>>>>>>> loud) etc.
>>>>>>>>
>>>>>>>>>> Second, you have claimed to have a 'non-halting behaviour
>>>>>>>>>> pattern', but nowhere have you ever provided proof that this
>>>>>>>>>> pattern is 'correct'. It's simply one of those things you've
>>>>>>>>>> 'stipulated'.
>>>>>>>>>>
>>>>>>>>>> André
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You found an error in my infinite loop detection and I credited
>>>>>>>>> you with this in my paper. So far no one has found any error in
>>>>>>>>> this:
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>>
>>>>>>>>> When we assume that the above is correct and we can see that the
>>>>>>>>> behavior of H_Hat() matches the above criteria then it
>>>>>>>>> necessarily follows that Halts(H_Hat, H_Hat) == 0 is correct.
>>>>>>>>
>>>>>>>> It's not incumbent on others to find flaws with your pattern. It's
>>>>>>>> incombent on *you* to prove that this pattern actually means what
>>>>>>>> you say it means and you have not done so.
>>>>>>>>
>>>>>>>> Does this following meet your criterion for 'infinite recursion'?
>>>>>>>>
>>>>>>>> void foo(void) {
>>>>>>>>       foo2();
>>>>>>>>       foo();
>>>>>>>> }
>>>>>>>>
>>>>>>>> André
>>>>>>>>
>>>>>>>
>>>>>>> I can't tell it might not compile because of a missing foo2() body.
>>>>>>
>>>>>> But that was my entire point. You can't know whether the above is
>>>>>> infinitely recursive or not without knowing how foo2() is defined.
>>>>>
>>>>> Do you really think that an at least partial halt decider must have
>>>>> psychic ability?
>>>>
>>>> Did I claim that it did?
>>>>
>>>>>> Your 'pattern matcher' needs to look *inside* all calls made. If
>>>>>> foo2() simply returns, then the above is infinitely recursive.
>>>>>
>>>>> Axiom(4)  with no function call returns from X()
>>>>> along with the other three axioms <is> sufficient.
>>>>>
>>>>> Axiom(4) is known to always be satisfied in the case of infinitely
>>>>> nested simulation because no simulator ever returns to the input that
>>>>> it is simulating.
>>>>
>>>> But your 'halts' isn't a simulator. It is a *modified* simulator, one
>>>> which stops simulating under certain circumstances. So you won't have
>>>> infinitely nested simulations.
>>>>
>>>>>> If foo2() enters an infinite loop, then the above isn't finite, but
>>>>>> it also isn't infinitely recursive. And if foo2() throws an
>>>>>> exception, the above will not be infinitely recursive, it will be
>>>>>> finite.
>>>>>>
>>>>>> However, in all your traces, you selectively skip over certain
>>>>>> function calls as if it is somehow possible to make an assessment
>>>>>> without considering what goes on inside every function call made
>>>>>> from the code you are looking at. That is your fatal mistake (well,
>>>>>> one of many).
>>>>>>
>>>>>> André
>>>>>>
>>>>>
>>>>> I only need to be able to correctly specify a very small number of
>>>>> cases to prove that H_Hat() matches an infinitely nested simulation
>>>>> pattern.
>>>>> As long as this pattern never matches any finite computation, then
>>>>> the pattern is sufficient for my purposes.
>>>>>
>>>>> void H_Hat(u32 P)
>>>>> {
>>>>>     u32 Input_Halts = Halts(P, P);
>>>>>     if (Input_Halts)
>>>>>       HERE: goto HERE;
>>>>> }
>>>>
>>>> But this is no different from the example I gave where you couldn't
>>>> assess it without knowing what occurs inside foo2(). You've defined
>>>> H_Hat but you've never actually shown us what occurs inside Halts()
>>>> (or you've defined it in terms of other undefined functions).
>>>>
>>>
>>> I know that Halts() never returns to its input and that it all the need
>>> be known to match the pattern.
>>>
>>
>> But it better return to its caller, even if its caller is another copy
>> of the machine it is simulating.
>>
> 
> Only the invocation of Halts() must return a value to its caller.
> Halts() cannot possibly return to any input that it is simulating.
> 
> When Halts() is called in infinitely nested simulation none of the
> nested simulations of Halts() ever return to their caller.
> 
> It is generally the case (basic software engineering) that every
> function called in infinite recursion or infinitely nested simulation
> never returns to its caller.

Ok, then you agree to this proof:

1) Halts is stipulated to meet the requirements of a Halt Decider for
Computation Theory, as used in the proof of Linz and Sipser.

2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when
asked directly.

3) H_Hat is stipulated to be built like Linz or Sipser, in that it will
halt when the Halt decider it is built on decides H_Hat’s input is
non-Halting on itself.

4) 1 Means that Halts is a Computation, and will always return the same
answer (or never return an answer) for a given input.

5) H_Hat(H_Hat) when run as a Machine will perform the Computation
Halts(H_Hat, H_Hat)

6) by 4 and 2, this means that Halts will return the decision on
non-halting to H_Hat

7) By 3, this means that H_Hat (the actual machine) will Halt.

8) This means that H_Hat is a Halting Computation, and because of 2,
Halts is wrong.


If not point out the mistake.

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


#33313 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-11 01:43 +0100
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<87lf8m3xt0.fsf@bsb.me.uk>
In reply to#33307
Richard Damon <Richard@Damon-Family.org> writes:

> Ok, then you agree to this proof:
>
> 1) Halts is stipulated to meet the requirements of a Halt Decider for
> Computation Theory, as used in the proof of Linz and Sipser.
>
> 2) Halts is stipulated to return non-Halting on Halts(H_Hat, H_Hat) when
> asked directly.
>
> 3) H_Hat is stipulated to be built like Linz or Sipser, in that it will
> halt when the Halt decider it is built on decides H_Hat’s input is
> non-Halting on itself.
>
> 4) 1 Means that Halts is a Computation, and will always return the same
> answer (or never return an answer) for a given input.
>
> 5) H_Hat(H_Hat) when run as a Machine will perform the Computation
> Halts(H_Hat, H_Hat)
>
> 6) by 4 and 2, this means that Halts will return the decision on
> non-halting to H_Hat
>
> 7) By 3, this means that H_Hat (the actual machine) will Halt.
>
> 8) This means that H_Hat is a Halting Computation, and because of 2,
> Halts is wrong.
>
>
> If not point out the mistake.

I admire you tenacity and clarity you try to bring to the debate, but PO
has rejected all the proof of the halting theorem, many of them unseen,
without pointing out the mistake in any of them.  He just says other
stuff, of varying degrees of silly, as the years go by.  His current
strategy is simply that false is the correct answer for some halting
computations.  He's not even talking about th halting problem anymore.

I think the best you can do when talking to a crank is to try to get
unambiguous information from them.  All cranks are terrified of
specifics because they can't bear to correct themselves (in any
significant way) so they know they will be stuck forever with everything
they say.  Ambiguity and waffle rules.  Clear statements of their
position are rare but sometimes come out.

You managing to get PO to post a trace of H_Hat(H_Hat) is an excellent
example.  He resisted for so long!

Other gems are his reply to my question:

||  First, do you really disagree with my simple statement that a
||  computation that halts, for whatever reason, is a halting computation?
|
| YES

and later:

|| (B) Every computation that halts, for whatever reason, is a halting
||     computation.
| OK

I wonder which he believes today.  I thought for a while he was going to
repudiate my favourite:

  "the fact that a computation halts does not entail that it is a halting
  computation"

but he only "made it more precise" and then said that his original words
"were not wrong".  In fact he's said similar things before.  For example:

  "To limit the scope of a halt decider to only report whether or not
  its input actually halts is to artificially constrain an otherwise
  correct halt decider."

  "That an otherwise correct halt decider can be broken by encoding it
  to get the wrong answer is trivial, that is one of the reasons why I
  don't embed the halt decider in H^."

(That last one is revealing for another reason!)

I know this is not really helpful, but I am feeling meta, today.

-- 
Ben.

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


#33236 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 22:57 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<Ri1mI.39310$zx1.35141@fx20.iad>
In reply to#33229
On 5/9/21 9:50 PM, olcott wrote:
> On 5/9/2021 7:51 PM, André G. Isaak wrote:
>> On 2021-05-09 18:37, olcott wrote:
>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>
>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>> simulator because it thinks the computation is non-halting does
>>>>>>>> not show
>>>>>>>> that the computation is halting, I think we all agree to that an
>>>>>>>> no one
>>>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>>>> about simulations that when WE talk about actually runnning
>>>>>>>> machines,
>>>>>>>> you still think about simulations.
>>>>>>>>
>>>>>>>>
>>>>>>>> Will you positively state that if we run that actual machine
>>>>>>>> itself, and
>>>>>>>> it halts, that it is a Halting Computation? Lay to rest
>>>>>>>> positively that
>>>>>>>> you would even consider a different definition?
>>>>>>>>
>>>>>>>
>>>>>>> **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.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>> Halts, then it is a Halting Computation?
>>>>>
>>>>> When any computation only halts because it was aborted at some point
>>>>> then this aborted computation <is not> a halting computation.
>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>
>>>> That simply isn't true. 
>>>
>>> The more you continue to dodge this point the less honest you prove
>>> to be:
>>>
>>> *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.
>>
>> First, 'impossibly incorrect' isn't meaningful English.
>>
> 
> It is the necessarily(X) of modal logic.
> 
>> Second, you have claimed to have a 'non-halting behaviour pattern',
>> but nowhere have you ever provided proof that this pattern is
>> 'correct'. It's simply one of those things you've 'stipulated'.
>>
>> André
>>
> 
> You found an error in my infinite loop detection and I credited you with
> this in my paper. So far no one has found any error in this:
> 
> 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.
> 
> When we assume that the above is correct and we can see that the
> behavior of H_Hat() matches the above criteria then it necessarily
> follows that Halts(H_Hat, H_Hat) == 0 is correct.
> 

UNPORVEN AND JUST BASED ON ASSUMPTIONS.

Defininition of Tracing is incorrect. It is incorrect to replace the
trace of the simulation of a call to Halts with a trace of the
simulation that Halts does.


Clarify #4, do you mean that X() contains no return instruction or no
return insturtion has been traced?

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


#33218 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 20:51 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<qs%lI.323170$2A5.283312@fx45.iad>
In reply to#33213
On 5/9/21 8:37 PM, olcott wrote:
> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>
>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>> simulator because it thinks the computation is non-halting does
>>>>>> not show
>>>>>> that the computation is halting, I think we all agree to that an
>>>>>> no one
>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>> about simulations that when WE talk about actually runnning machines,
>>>>>> you still think about simulations.
>>>>>>
>>>>>>
>>>>>> Will you positively state that if we run that actual machine
>>>>>> itself, and
>>>>>> it halts, that it is a Halting Computation? Lay to rest positively
>>>>>> that
>>>>>> you would even consider a different definition?
>>>>>>
>>>>>
>>>>> **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.
>>>>>
>>>>>
>>>>
>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>> Halts, then it is a Halting Computation?
>>>
>>> When any computation only halts because it was aborted at some point
>>> then this aborted computation <is not> a halting computation.
>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>
>> That simply isn't true. 
> 
> The more you continue to dodge this point the less honest you prove to be:
> 
> *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.
> 

And you have YET to actually PROVE that your non-halting behavior
pattern is actually correct, or that you correctly decide based on it.

one FATAL flaw is that you replace the simulated call to Halts, which
should show the code inside Halts, with a trace of the machine it is
simulating.\

THIS IS NOT AN EQUIVALENCE.

IF Halts was a PURE UTM, then you could argue this, as that says that if
the machine being simulated was infinite, then the call to Halts would
be also. BUT, since Halts can abort the simulation, the substituition of
the simulated code might make the machine run longer, even infinitely
longer than it actaully does.

This makes that action improper, and the argument unsound.

If your patterns allow this, they are incorrect.

If they don't, then you didn't correctly apply them.

Either way, you don't have PROOF that you are right, just bad arguments.

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


#33220 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 01:09 +0000
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<20210509180307.579@kylheku.com>
In reply to#33213
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>
>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>> simulator because it thinks the computation is non-halting does not show
>>>>>> that the computation is halting, I think we all agree to that an no one
>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>> about simulations that when WE talk about actually runnning machines,
>>>>>> you still think about simulations.
>>>>>>
>>>>>>
>>>>>> Will you positively state that if we run that actual machine itself, and
>>>>>> it halts, that it is a Halting Computation? Lay to rest positively that
>>>>>> you would even consider a different definition?
>>>>>>
>>>>>
>>>>> **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.
>>>>>
>>>>>
>>>>
>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>> Halts, then it is a Halting Computation?
>>>
>>> When any computation only halts because it was aborted at some point
>>> then this aborted computation <is not> a halting computation.
>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>> 
>> That simply isn't true. 
>
> The more you continue to dodge this point the less honest you prove to be:

Though it is hardly necessary at this point, I can reference execution
trace details given in your postings.

Please make a statement confirming that your execution traces are
worthless garbage which you are retracting.

Then I will retract all statements I ever made referencing your
execution traces.

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


#33222 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 20:24 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<rL6dnZzgGLGtFgX9nZ2dnUU7-cXNnZ2d@giganews.com>
In reply to#33220
On 5/9/2021 8:09 PM, Kaz Kylheku wrote:
> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>
>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>> simulator because it thinks the computation is non-halting does not show
>>>>>>> that the computation is halting, I think we all agree to that an no one
>>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>>> about simulations that when WE talk about actually runnning machines,
>>>>>>> you still think about simulations.
>>>>>>>
>>>>>>>
>>>>>>> Will you positively state that if we run that actual machine itself, and
>>>>>>> it halts, that it is a Halting Computation? Lay to rest positively that
>>>>>>> you would even consider a different definition?
>>>>>>>
>>>>>>
>>>>>> **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.
>>>>>>
>>>>>>
>>>>>
>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>> Halts, then it is a Halting Computation?
>>>>
>>>> When any computation only halts because it was aborted at some point
>>>> then this aborted computation <is not> a halting computation.
>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>
>>> That simply isn't true.
>>
>> The more you continue to dodge this point the less honest you prove to be:
> 
> Though it is hardly necessary at this point, I can reference execution
> trace details given in your postings.
> 
> Please make a statement confirming that your execution traces are
> worthless garbage which you are retracting.
> 
> Then I will retract all statements I ever made referencing your
> execution traces.
> 

There is never any time that you verified that this is true or found any 
error where it is false:

When any computation only halts because it was aborted at some point
then this aborted computation <is not> a halting computation.
H_Hat(H_Hat) only halts because it is aborted at some point.

This is the single point that I am willing to discuss with you because 
you are the only one here that both knows enough to verify the truth of 
it without getting confused and not utterly set on making sure that you 
disagree with me even at the expense of truth.



-- 
Copyright 2021 Pete Olcott

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

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


#33228 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 01:47 +0000
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<20210509184127.852@kylheku.com>
In reply to#33222
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
> On 5/9/2021 8:09 PM, Kaz Kylheku wrote:
>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>
>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>> simulator because it thinks the computation is non-halting does not show
>>>>>>>> that the computation is halting, I think we all agree to that an no one
>>>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>>>> about simulations that when WE talk about actually runnning machines,
>>>>>>>> you still think about simulations.
>>>>>>>>
>>>>>>>>
>>>>>>>> Will you positively state that if we run that actual machine itself, and
>>>>>>>> it halts, that it is a Halting Computation? Lay to rest positively that
>>>>>>>> you would even consider a different definition?
>>>>>>>>
>>>>>>>
>>>>>>> **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.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>> Halts, then it is a Halting Computation?
>>>>>
>>>>> When any computation only halts because it was aborted at some point
>>>>> then this aborted computation <is not> a halting computation.
>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>
>>>> That simply isn't true.
>>>
>>> The more you continue to dodge this point the less honest you prove to be:
>> 
>> Though it is hardly necessary at this point, I can reference execution
>> trace details given in your postings.
>> 
>> Please make a statement confirming that your execution traces are
>> worthless garbage which you are retracting.
>> 
>> Then I will retract all statements I ever made referencing your
>> execution traces.
>> 
>
> There is never any time that you verified that this is true or found any 
> error where it is false:
>
> When any computation only halts because it was aborted at some point
> then this aborted computation <is not> a halting computation.
> H_Hat(H_Hat) only halts because it is aborted at some point.

But it isn't. main or H_Hat call Halts. Halts initializes a CPU
simulation, and steps it. At some point, Halts thinks it sees some
funny pattern, quits and returns 0.

In what way does that constitute Halts being aborted?

> This is the single point that I am willing to discuss with you because 
> you are the only one here that both knows enough to verify the truth of 
> it without getting confused and not utterly set on making sure that you 
> disagree with me even at the expense of truth.

A function call is a mechanism whereby a caller is suspended in order
to execute some code elsewhere. The caller remains suspended until that
calculation terminates, at which point the caller is resumed and has
access to the value produced by the terminated calculation (if any,
depending on type).

Everything which looks like that situation is a call and return.

If it looks like a return, walks like a duck and quacks like return,
it's a return.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal We

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


#33230 — Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 20:53 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<5-Sdnde87-CRDwX9nZ2dnUU7-LmdnZ2d@giganews.com>
In reply to#33228
On 5/9/2021 8:47 PM, Kaz Kylheku wrote:
> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>> On 5/9/2021 8:09 PM, Kaz Kylheku wrote:
>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>> On 5/9/2021 7:25 PM, Kaz Kylheku wrote:
>>>>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 5/9/2021 7:07 PM, Richard Damon wrote:
>>>>>>> On 5/9/21 7:38 PM, olcott wrote:
>>>>>>>> On 5/9/2021 6:10 PM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> IF your statement is that the stopping of the simulation by the
>>>>>>>>> simulator because it thinks the computation is non-halting does not show
>>>>>>>>> that the computation is halting, I think we all agree to that an no one
>>>>>>>>> has said any different. I think you just get so stuck into thinking
>>>>>>>>> about simulations that when WE talk about actually runnning machines,
>>>>>>>>> you still think about simulations.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Will you positively state that if we run that actual machine itself, and
>>>>>>>>> it halts, that it is a Halting Computation? Lay to rest positively that
>>>>>>>>> you would even consider a different definition?
>>>>>>>>>
>>>>>>>>
>>>>>>>> **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.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> BUT, do you agree that if when we run a machine itself, that if it
>>>>>>> Halts, then it is a Halting Computation?
>>>>>>
>>>>>> When any computation only halts because it was aborted at some point
>>>>>> then this aborted computation <is not> a halting computation.
>>>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>>>
>>>>> That simply isn't true.
>>>>
>>>> The more you continue to dodge this point the less honest you prove to be:
>>>
>>> Though it is hardly necessary at this point, I can reference execution
>>> trace details given in your postings.
>>>
>>> Please make a statement confirming that your execution traces are
>>> worthless garbage which you are retracting.
>>>
>>> Then I will retract all statements I ever made referencing your
>>> execution traces.
>>>
>>
>> There is never any time that you verified that this is true or found any
>> error where it is false:
>>
>> When any computation only halts because it was aborted at some point
>> then this aborted computation <is not> a halting computation.
>> H_Hat(H_Hat) only halts because it is aborted at some point.
> 
> But it isn't. main or H_Hat call Halts. Halts initializes a CPU
> simulation, and steps it. At some point, Halts thinks it sees some
> funny pattern, quits and returns 0.
> 
> In what way does that constitute Halts being aborted?
> 
>> This is the single point that I am willing to discuss with you because
>> you are the only one here that both knows enough to verify the truth of
>> it without getting confused and not utterly set on making sure that you
>> disagree with me even at the expense of truth.
> 
> A function call is a mechanism whereby a caller is suspended in order
> to execute some code elsewhere. The caller remains suspended until that
> calculation terminates, at which point the caller is resumed and has
> access to the value produced by the terminated calculation (if any,
> depending on type).
> 
> Everything which looks like that situation is a call and return.
> 
> If it looks like a return, walks like a duck and quacks like return,
> it's a return.
> 

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.

For recursive simulation (4) is always met because no simualator ever 
returns to the input that it is simulating.


-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web