Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.theory > #33180 > unrolled thread
| Started by | Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> |
|---|---|
| First post | 2021-05-09 20:01 +0100 |
| Last post | 2021-06-27 22:19 -0700 |
| Articles | 20 on this page of 87 — 12 participants |
Back to article view | Back to comp.theory
This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by
below is the oldest one visible, not the original post.
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 20:01 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 14:11 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:03 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:11 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:33 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:39 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-05-09 13:43 -0700
Re: Halting problem undecidability and infinite recursion (PDF attached) Siri Cruise <chine.bleu@yahoo.com> - 2021-05-09 13:45 -0700
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:54 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:56 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 16:00 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 17:40 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached) Siri Cruise <chine.bleu@yahoo.com> - 2021-05-09 14:00 -0700
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 16:04 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 17:42 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-09 23:32 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 17:57 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 19:10 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( impossibly incorrect ) olcott <NoOne@NoWhere.com> - 2021-05-09 18:38 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( impossibly incorrect ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:07 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 00:25 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:37 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 18:51 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:50 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 20:33 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 21:43 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 21:06 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 22:36 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 22:31 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 23:41 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 08:17 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:32 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 19:46 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 01:43 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 22:57 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:51 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 01:09 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:24 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 01:47 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:53 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:00 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:00 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:30 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:42 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:58 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:11 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 18:49 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:45 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 20:36 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 21:51 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:03 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 05:41 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:06 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 19:47 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:02 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 02:31 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:43 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:08 -0400
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 05:32 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:05 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 16:33 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 11:49 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 16:58 +0000
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 12:09 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 11:54 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:21 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 17:00 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 11:22 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 23:59 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 18:05 -0500
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Jeff Barnett <jbb@notatt.com> - 2021-05-10 17:33 -0600
Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 02:03 +0100
Re: Halting problem undecidability and infinite recursion (PDF attached) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 02:28 +0100
Re: Halting problem undecidability and infinite recursion (PO=Deluded Dumbo) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 04:03 +0100
Re: Halting problem undecidability and infinite recursion [ necessarily(P) ] olcott <NoOne@NoWhere.com> - 2021-05-09 22:25 -0500
Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 16:18 +0100
Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 10:25 -0500
Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 17:27 +0100
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 11:37 -0500
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 00:16 +0100
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 18:57 -0500
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 02:17 +0100
Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Richard Damon <Richard@Damon-Family.org> - 2021-05-10 22:56 -0400
Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-05-10 10:15 -0700
Re: Halting problem undecidability and infinite recursion [ Mike says Proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 11:17 -0500
Re: Halting problem undecidability and infinite recursion [sound deductive argument = proof ] olcott <NoOne@NoWhere.com> - 2021-06-27 21:35 -0500
Re: Halting problem undecidability and infinite recursion [sound deductive argument = proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-06-27 22:19 -0700
Page 2 of 5 — ← Prev page 1 [2] 3 4 5 Next page →
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-10 00:25 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 19:37 -0500 |
| Subject | Re: 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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-05-09 18:51 -0600 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 20:50 -0500 |
| Subject | Re: 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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-05-09 20:33 -0600 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 21:43 -0500 |
| Subject | Re: 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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-05-09 21:06 -0600 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 22:36 -0500 |
| Subject | Re: 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]
| From | André G. Isaak <agisaak@gm.invalid> |
|---|---|
| Date | 2021-05-09 22:31 -0600 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 23:41 -0500 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-10 08:17 -0400 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-10 08:32 -0500 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-10 19:46 -0400 |
| Subject | Re: 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]
| From | Ben Bacarisse <ben.usenet@bsb.me.uk> |
|---|---|
| Date | 2021-05-11 01:43 +0100 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-09 22:57 -0400 |
| Subject | Re: 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]
| From | Richard Damon <Richard@Damon-Family.org> |
|---|---|
| Date | 2021-05-09 20:51 -0400 |
| Subject | Re: 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-10 01:09 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 20:24 -0500 |
| Subject | Re: 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]
| From | Kaz Kylheku <563-365-8930@kylheku.com> |
|---|---|
| Date | 2021-05-10 01:47 +0000 |
| Subject | Re: 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]
| From | olcott <NoOne@NoWhere.com> |
|---|---|
| Date | 2021-05-09 20:53 -0500 |
| Subject | Re: 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