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


Groups > comp.theory > #33180 > unrolled thread

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

Started byMr Flibble <flibble@i42.REMOVETHISBIT.co.uk>
First post2021-05-09 20:01 +0100
Last post2021-06-27 22:19 -0700
Articles 20 on this page of 87 — 12 participants

Back to article view | Back to comp.theory

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.


Contents

  Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 20:01 +0100
    Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 14:11 -0500
      Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:03 +0100
        Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:11 -0500
          Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:33 +0100
            Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:39 -0500
              Re: Halting problem undecidability and infinite recursion (PDF attached) "Chris M. Thomasson" <chris.m.thomasson.1@gmail.com> - 2021-05-09 13:43 -0700
    Re: Halting problem undecidability and infinite recursion (PDF attached) Siri Cruise <chine.bleu@yahoo.com> - 2021-05-09 13:45 -0700
      Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 15:54 -0500
        Re: Halting problem undecidability and infinite recursion (PDF attached) Mr Flibble <flibble@i42.REMOVETHISBIT.co.uk> - 2021-05-09 21:56 +0100
          Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 16:00 -0500
            Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 17:40 -0400
        Re: Halting problem undecidability and infinite recursion (PDF attached) Siri Cruise <chine.bleu@yahoo.com> - 2021-05-09 14:00 -0700
          Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 16:04 -0500
            Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 17:42 -0400
            Re: Halting problem undecidability and infinite recursion (PDF attached) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-09 23:32 +0100
              Re: Halting problem undecidability and infinite recursion (PDF attached) olcott <NoOne@NoWhere.com> - 2021-05-09 17:57 -0500
                Re: Halting problem undecidability and infinite recursion (PDF attached) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 19:10 -0400
                  Re: Halting problem undecidability and infinite recursion (PDF attached)( impossibly incorrect ) olcott <NoOne@NoWhere.com> - 2021-05-09 18:38 -0500
                    Re: Halting problem undecidability and infinite recursion (PDF attached)( impossibly incorrect ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:07 -0400
                      Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 00:25 +0000
                        Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:37 -0500
                          Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 18:51 -0600
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:50 -0500
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 20:33 -0600
                                Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 21:43 -0500
                                  Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 21:06 -0600
                                    Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 22:36 -0500
                                      Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 22:31 -0600
                                        Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 23:41 -0500
                                          Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 08:17 -0400
                                            Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:32 -0500
                                              Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 19:46 -0400
                                                Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 01:43 +0100
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 22:57 -0400
                          Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:51 -0400
                          Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 01:09 +0000
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:24 -0500
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 01:47 +0000
                                Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:53 -0500
                                  Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:00 -0400
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:00 -0400
                      Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:30 -0400
                        Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:42 -0500
                          Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 20:58 -0400
                      Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 19:11 -0500
                        Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 18:49 -0600
                          Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:45 -0500
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) André G. Isaak <agisaak@gm.invalid> - 2021-05-09 20:36 -0600
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 21:51 -0500
                                Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:03 -0400
                                Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 05:41 +0000
                                  Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:06 -0500
                                    Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-10 19:47 -0400
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:02 -0400
                        Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 02:31 +0100
                          Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-09 20:43 -0500
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Richard Damon <Richard@Damon-Family.org> - 2021-05-09 23:08 -0400
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 05:32 +0000
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:05 -0500
                                Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 16:33 +0000
                                  Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 11:49 -0500
                                    Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Kaz Kylheku <563-365-8930@kylheku.com> - 2021-05-10 16:58 +0000
                                      Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 12:09 -0500
                            Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 11:54 +0100
                              Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 08:21 -0500
                                Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 17:00 +0100
                                  Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 11:22 -0500
                                    Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 23:59 +0100
                                      Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) olcott <NoOne@NoWhere.com> - 2021-05-10 18:05 -0500
                                        Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Jeff Barnett <jbb@notatt.com> - 2021-05-10 17:33 -0600
                                        Re: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point ) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 02:03 +0100
                Re: Halting problem undecidability and infinite recursion (PDF attached) Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-10 02:28 +0100
            Re: Halting problem undecidability and infinite recursion (PO=Deluded Dumbo) Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 04:03 +0100
              Re: Halting problem undecidability and infinite recursion [ necessarily(P) ] olcott <NoOne@NoWhere.com> - 2021-05-09 22:25 -0500
                Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 16:18 +0100
                  Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 10:25 -0500
                    Re: Halting problem undecidability and infinite recursion [ PO=Deluded Dumbo ] Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2021-05-10 17:27 +0100
                      Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 11:37 -0500
                        Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 00:16 +0100
                          Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 18:57 -0500
                            Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Ben Bacarisse <ben.usenet@bsb.me.uk> - 2021-05-11 02:17 +0100
                            Re: Halting problem undecidability and infinite recursion [ Mike agrees proof is correct ] Richard Damon <Richard@Damon-Family.org> - 2021-05-10 22:56 -0400
                    Re: Halting problem undecidability and infinite recursion [ Necessarily correct ] Malcolm McLean <malcolm.arthur.mclean@gmail.com> - 2021-05-10 10:15 -0700
                  Re: Halting problem undecidability and infinite recursion [ Mike says Proof is correct ] olcott <NoOne@NoWhere.com> - 2021-05-10 11:17 -0500
                  Re: Halting problem undecidability and infinite recursion [sound deductive argument = proof ] olcott <NoOne@NoWhere.com> - 2021-06-27 21:35 -0500
                    Re: Halting problem undecidability and infinite recursion [sound deductive argument = proof ] Daniel Pehoushek <pehoushek1@gmail.com> - 2021-06-27 22:19 -0700

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 23:00 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<Ll1mI.39312$zx1.8473@fx20.iad>
In reply to#33230
On 5/9/21 9:53 PM, olcott wrote:
> 
> 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.
> 
> 

But does Halts return to the machine that called it?

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 23:00 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( honest dialogue ? )
Message-ID<Xk1mI.39311$zx1.29609@fx20.iad>
In reply to#33222
On 5/9/21 9:24 PM, olcott 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.
> 
> 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.
> 
>

The following trace of a run of H_Hat(H_Hat) is provided from YOU.

There is a comment about aborting, but that is of the SIMULATION of
H_Hat inside the computation, not of H_Hat itself.

It shows that H_Hat(H_Hat) does halt.


On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
>  u32 Input_Halts = Halts(P, P);
>  if (Input_Halts)
>    HERE: goto HERE;
> }
>
>
> int main()
> {
>  H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01)  55                  	push ebp
> [00000b99](02)  8bec                	mov ebp,esp
>
[00000b9b](01)  51                  	push ecx
> [00000b9c](03)  8b4508              	mov eax,[ebp+08]
> [00000b9f](01)  50                  	push eax
> [00000ba0](03)  8b4d08              	mov ecx,[ebp+08]
> [00000ba3](01)  51                  	push ecx
> [00000ba4](05)  e88ffdffff          	call 00000938
> [00000ba9](03)  83c408              	add esp,+08
> [00000bac](03)  8945fc              	mov [ebp-04],eax
> [00000baf](04)  837dfc00            	cmp dword [ebp-04],+00
> [00000bb3](02)  7402                	jz 00000bb7
> [00000bb5](02)  ebfe                	jmp 00000bb5
> [00000bb7](02)  8be5                	mov esp,ebp
> [00000bb9](01)  5d                  	pop ebp
> [00000bba](01)  c3                  	ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01)  55                  	push ebp
> [00000bc9](02)  8bec                	mov ebp,esp
> [00000bcb](05)  68980b0000          push 00000b98
> [00000bd0](05)  e8c3ffffff          	call 00000b98
> [00000bd5](03)  83c404              	add esp,+04
> [00000bd8](02)  33c0                	xor eax,eax
> [00000bda](01)  5d                  	pop ebp
> [00000bdb](01)  c3                  	ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01)  55         push ebp
> ...[00000bc9][001015d4][00000000](02)  8bec       mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05)  68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01)  55         push ebp
> ...[00000b99][001015c8][001015d4](02)  8bec       mov ebp,esp
> ...[00000b9b][001015c4][00000000](01)  51         push ecx
> ...[00000b9c][001015c4][00000000](03)  8b4508     mov  eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01)  50         push eax
> ...[00000ba0][001015c0][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01)  51         push ecx
> ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01)  55         push ebp
> ...[00000b99][00211674][00211678](02)  8bec       mov ebp,esp
> ...[00000b9b][00211670][00201644](01)  51         push ecx
> ...[00000b9c][00211670][00201644](03)  8b4508     mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01)  50         push eax
> ...[00000ba0][0021166c][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01)  51         push ecx
> ...[00000ba4][00211664][00000ba9](05)  e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01)  55         push ebp
> ...[00000b99][0025c09c][0025c0a0](02)  8bec       mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01)  51         push ecx
> ...[00000b9c][0025c098][0024c06c](03)  8b4508     mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01)  50         push eax
> ...[00000ba0][0025c094][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01)  51         push ecx
> ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
> ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
> ...[00000bba][001015d0][00000b98](01)  c3         ret
> ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
> ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
> ...[00000bda][001015d8][00100000](01)  5d         pop ebp
> ...[00000bdb][001015dc][00000098](01)  c3         ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)



On 5/7/21 7:21 PM, olcott wrote:
Message-ID: <ofudnRYWdJL4Vgj9nZ2dnUU7-fPNnZ2d@giganews.com>
> When we make sure not to conflate the behavior of the halt decider with
> the behavior of its input then the fact that a computation halts does
> not entail that it is a halting computation.


>

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 20:30 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<T8%lI.45710$mO3.26815@fx09.iad>
In reply to#33210
On 5/9/21 8:11 PM, olcott 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.
> 

FALSE.

H_Hat(H_Hat) when run as a machine has NOTHING that CAN abort it.


Remember, I said H_Hat run as a machine, not as an input to Halts.

It calls Halts(H_Hat, H_Hat) which then simulates the machine
description which it is given, which just happens to match the
description of the machine it is running in, and Halts will abort its
simulation of that description. IT can NOT abort the machine that called
it, at least not a be a computation and a decider, at least if H_Hat was
built by the instructions,

So which is you lie:

Are you intentionally conflating that it aborted a simulation and trying
to say that this somehow automagically aborts the actual machine that
was running that called it?

or

Is Halts NOT a decider, because it NEVER returned its answer in the
manner required?

or

Is Halts NOT even a computation, doing different things based on
different environments of being called, and thus not even a Turing
Machine Equivalent?


Please explain which ERROR you are making?

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 19:42 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<Xomdne4KGt7FHAX9nZ2dnUU7-RPNnZ2d@giganews.com>
In reply to#33212
On 5/9/2021 7:30 PM, Richard Damon wrote:
> On 5/9/21 8:11 PM, olcott 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.
>>
> 
> FALSE.
> 
> H_Hat(H_Hat) when run as a machine has NOTHING that CAN abort it.
> 
void H_Hat(u32 P)
{

// Halts correctly decides that H_Hat(H_Hat)
// specifies Infinitely recursive simulation
// and it is aborted right here.

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



-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 20:58 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<gz%lI.95865$9L1.54815@fx05.iad>
In reply to#33214
On 5/9/21 8:42 PM, olcott wrote:
> On 5/9/2021 7:30 PM, Richard Damon wrote:
>> On 5/9/21 8:11 PM, olcott 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.
>>>
>>
>> FALSE.
>>
>> H_Hat(H_Hat) when run as a machine has NOTHING that CAN abort it.
>>
> void H_Hat(u32 P)
> {
> 
> // Halts correctly decides that H_Hat(H_Hat)
> // specifies Infinitely recursive simulation
> // and it is aborted right here.
> 
>   u32 Input_Halts = Halts(P, P);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
> 
> 
> 
Right, so we run this as a machine.

Trace is:

void H_Hat(H_Hat)

u32 Input_Halts = Halts(H_Hat, H_Hat)

we now don't have the code to trace but we do have the following promises.

Halts is a computation, thus what it did once with a given input, it
will do every time with that same input.

We have that Halts(H_Hat, H_Hat) when run as a machine says non-halting.

Thus Halts will simulate H_Hat(H_Hat) for a while, and the stop its
simulation and return non-halting.

Thus Input_Halts = False

if(False)	// skip loop
}
// Machine stops.

Therefore, H_Hat(H_Hat) has been shown to halt as long as Halts meets
the requirements it must meet the requirement of a halt decider.


You have even provided your own trace of this, note, the comments
printed by Halts deals with the simulation of H_Hat it is doing, and it
stops its simulation of that H_Hat. The H_Hat traced above is NOT that
simulation.


On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
>  u32 Input_Halts = Halts(P, P);
>  if (Input_Halts)
>    HERE: goto HERE;
> }
>
>
> int main()
> {
>  H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01)  55                  	push ebp
> [00000b99](02)  8bec                	mov ebp,esp
>
[00000b9b](01)  51                  	push ecx
> [00000b9c](03)  8b4508              	mov eax,[ebp+08]
> [00000b9f](01)  50                  	push eax
> [00000ba0](03)  8b4d08              	mov ecx,[ebp+08]
> [00000ba3](01)  51                  	push ecx
> [00000ba4](05)  e88ffdffff          	call 00000938
> [00000ba9](03)  83c408              	add esp,+08
> [00000bac](03)  8945fc              	mov [ebp-04],eax
> [00000baf](04)  837dfc00            	cmp dword [ebp-04],+00
> [00000bb3](02)  7402                	jz 00000bb7
> [00000bb5](02)  ebfe                	jmp 00000bb5
> [00000bb7](02)  8be5                	mov esp,ebp
> [00000bb9](01)  5d                  	pop ebp
> [00000bba](01)  c3                  	ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01)  55                  	push ebp
> [00000bc9](02)  8bec                	mov ebp,esp
> [00000bcb](05)  68980b0000          push 00000b98
> [00000bd0](05)  e8c3ffffff          	call 00000b98
> [00000bd5](03)  83c404              	add esp,+04
> [00000bd8](02)  33c0                	xor eax,eax
> [00000bda](01)  5d                  	pop ebp
> [00000bdb](01)  c3                  	ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01)  55         push ebp
> ...[00000bc9][001015d4][00000000](02)  8bec       mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05)  68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01)  55         push ebp
> ...[00000b99][001015c8][001015d4](02)  8bec       mov ebp,esp
> ...[00000b9b][001015c4][00000000](01)  51         push ecx
> ...[00000b9c][001015c4][00000000](03)  8b4508     mov  eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01)  50         push eax
> ...[00000ba0][001015c0][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01)  51         push ecx
> ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01)  55         push ebp
> ...[00000b99][00211674][00211678](02)  8bec       mov ebp,esp
> ...[00000b9b][00211670][00201644](01)  51         push ecx
> ...[00000b9c][00211670][00201644](03)  8b4508     mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01)  50         push eax
> ...[00000ba0][0021166c][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01)  51         push ecx
> ...[00000ba4][00211664][00000ba9](05)  e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01)  55         push ebp
> ...[00000b99][0025c09c][0025c0a0](02)  8bec       mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01)  51         push ecx
> ...[00000b9c][0025c098][0024c06c](03)  8b4508     mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01)  50         push eax
> ...[00000ba0][0025c094][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01)  51         push ecx
> ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
> ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
> ...[00000bba][001015d0][00000b98](01)  c3         ret
> ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
> ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
> ...[00000bda][001015d8][00100000](01)  5d         pop ebp
> ...[00000bdb][001015dc][00000098](01)  c3         ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)



On 5/7/21 7:21 PM, olcott wrote:
Message-ID: <ofudnRYWdJL4Vgj9nZ2dnUU7-fPNnZ2d@giganews.com>
> When we make sure not to conflate the behavior of the halt decider with
> the behavior of its input then the fact that a computation halts does
> not entail that it is a halting computation.


>

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 19:11 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<16adneJOm_mj5wX9nZ2dnUU7-KHNnZ2d@giganews.com>
In reply to#33210
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.


-- 
Copyright 2021 Pete Olcott

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

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


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

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-05-09 18:49 -0600
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<s79vum$9a0$1@dont-email.me>
In reply to#33215
On 2021-05-09 18:11, olcott 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.

You're suffering from sloppy pronouns here. What does 'it' refer to above?

When run as an independent computation, nothing 'aborts' H_Hat(H_Hat).

Inside H_Hat, we have a call to Halts(H_Hat, H_Hat), but this isn't a 
computation. It is a partial simulation which is *part* of the 
computation being performed by H_Hat(H_Hat). That partial simulation 
might be prematurely stopped, but that isn't the same thing as aborting 
the topmost H_Hat(H_Hat). After your simulator prematurely stops, 
H_Hat(H_Hat) halts. It isn't 'aborted'. It simply halts.

André

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 20:45 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<-4udnVBoic6GDQX9nZ2dnUU7-SudnZ2d@giganews.com>
In reply to#33216
On 5/9/2021 7:49 PM, André G. Isaak wrote:
> On 2021-05-09 18:11, olcott 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.
> 
> You're suffering from sloppy pronouns here. What does 'it' refer to above?
> 
> When run as an independent computation, nothing 'aborts' H_Hat(H_Hat).
> 
> Inside H_Hat, we have a call to Halts(H_Hat, H_Hat), but this isn't a 
> computation. It is a partial simulation which is *part* of the 
> computation being performed by H_Hat(H_Hat). That partial simulation 
> might be prematurely stopped, but that isn't the same thing as aborting 
> the topmost H_Hat(H_Hat). After your simulator prematurely stops, 
> H_Hat(H_Hat) halts. It isn't 'aborted'. It simply halts.
> 
> André
> 

When the execution trace of H_Hat() correctly matches a correct
non-halting behavior pattern then the decision of non-halting is
impossibly incorrect.

Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct and 
we know that H_Hat(H_Hat) halts what could explain this?




-- 
Copyright 2021 Pete Olcott

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

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


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

FromAndré G. Isaak <agisaak@gm.invalid>
Date2021-05-09 20:36 -0600
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<s7a671$cjq$2@dont-email.me>
In reply to#33227
On 2021-05-09 19:45, olcott wrote:
> On 5/9/2021 7:49 PM, André G. Isaak wrote:
>> On 2021-05-09 18:11, olcott 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.
>>
>> You're suffering from sloppy pronouns here. What does 'it' refer to 
>> above?
>>
>> When run as an independent computation, nothing 'aborts' H_Hat(H_Hat).
>>
>> Inside H_Hat, we have a call to Halts(H_Hat, H_Hat), but this isn't a 
>> computation. It is a partial simulation which is *part* of the 
>> computation being performed by H_Hat(H_Hat). That partial simulation 
>> might be prematurely stopped, but that isn't the same thing as 
>> aborting the topmost H_Hat(H_Hat). After your simulator prematurely 
>> stops, H_Hat(H_Hat) halts. It isn't 'aborted'. It simply halts.
>>
>> André
>>
> 
> 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 you haven't provided evidence that your pattern is a 'correct' pattern.

> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct and 
> we know that H_Hat(H_Hat) halts what could explain this?

This is a silly question, because we *don't* know that Halts(H_Hat, 
H_Hat) == 0 is correct. In fact we know that it is *incorrect* based on 
the fact that H_Hat(H_Hat) halts.

André

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 21:51 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<WtydnRDJSOdYAgX9nZ2dnUU7-UfNnZ2d@giganews.com>
In reply to#33232
On 5/9/2021 9:36 PM, André G. Isaak wrote:
> On 2021-05-09 19:45, olcott wrote:
>> On 5/9/2021 7:49 PM, André G. Isaak wrote:
>>> On 2021-05-09 18:11, olcott 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.
>>>
>>> You're suffering from sloppy pronouns here. What does 'it' refer to 
>>> above?
>>>
>>> When run as an independent computation, nothing 'aborts' H_Hat(H_Hat).
>>>
>>> Inside H_Hat, we have a call to Halts(H_Hat, H_Hat), but this isn't a 
>>> computation. It is a partial simulation which is *part* of the 
>>> computation being performed by H_Hat(H_Hat). That partial simulation 
>>> might be prematurely stopped, but that isn't the same thing as 
>>> aborting the topmost H_Hat(H_Hat). After your simulator prematurely 
>>> stops, H_Hat(H_Hat) halts. It isn't 'aborted'. It simply halts.
>>>
>>> André
>>>
>>
>> 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 you haven't provided evidence that your pattern is a 'correct' pattern.
> 

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.

If we assume that the above criteria is correct and we can see that it 
does match the execution trace of H_Hat then the only possible way that
Halts(H_Hat, H_Hat) == 0 is incorrect is that the criteria is incorrect.

>> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct 
>> and we know that H_Hat(H_Hat) halts what could explain this?
> 
> This is a silly question, because we *don't* know that Halts(H_Hat, 
> H_Hat) == 0 is correct. In fact we know that it is *incorrect* based on 
> the fact that H_Hat(H_Hat) halts.
> 
> André
> 



-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 23:03 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<no1mI.39314$zx1.6527@fx20.iad>
In reply to#33234
On 5/9/21 10:51 PM, olcott wrote:
> On 5/9/2021 9:36 PM, André G. Isaak wrote:
>> On 2021-05-09 19:45, olcott wrote:
>>> On 5/9/2021 7:49 PM, André G. Isaak wrote:
>>>> On 2021-05-09 18:11, olcott 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.
>>>>
>>>> You're suffering from sloppy pronouns here. What does 'it' refer to
>>>> above?
>>>>
>>>> When run as an independent computation, nothing 'aborts' H_Hat(H_Hat).
>>>>
>>>> Inside H_Hat, we have a call to Halts(H_Hat, H_Hat), but this isn't
>>>> a computation. It is a partial simulation which is *part* of the
>>>> computation being performed by H_Hat(H_Hat). That partial simulation
>>>> might be prematurely stopped, but that isn't the same thing as
>>>> aborting the topmost H_Hat(H_Hat). After your simulator prematurely
>>>> stops, H_Hat(H_Hat) halts. It isn't 'aborted'. It simply halts.
>>>>
>>>> André
>>>>
>>>
>>> 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 you haven't provided evidence that your pattern is a 'correct'
>> pattern.
>>
> 
> 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.
> 
> If we assume that the above criteria is correct and we can see that it
> does match the execution trace of H_Hat then the only possible way that
> Halts(H_Hat, H_Hat) == 0 is incorrect is that the criteria is incorrect.
> 

Stateing something does NOT prove it!!!!!


Clarification, does (4) only mean traced or existing in the function,
you have made comments both ways.

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 05:41 +0000
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<20210509223256.245@kylheku.com>
In reply to#33234
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
> 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()

But X corresponds to Halts and that is appearing to return.

So ... the idea that your calculation is detecting a situation meeting
all the above rules rules depends on your insistence that Halts is not
perpetrating a function call return.

This is in spite of Halts appearing to do so in your execution traces.

Halts is invoked via a CALL instruction, which somehow or other
returns, with the 0 value in EAX.

Why should anyone accept your stipulation that a CALL which passed
control back to the calling stack frame has not returned?

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 08:06 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<2_qdnSZO99l4sgT9nZ2dnUU7-Q2dnZ2d@giganews.com>
In reply to#33250
On 5/10/2021 12:41 AM, Kaz Kylheku wrote:
> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>> 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()
> 
> But X corresponds to Halts and that is appearing to return.
> 

Good catch.

The rule had to be corrected
(4) with no function call returns from X()
was changed to this
(4) with no function call returns from X() to Y()

No simulator every returns to the program that it is simulating.

> So ... the idea that your calculation is detecting a situation meeting
> all the above rules rules depends on your insistence that Halts is not
> perpetrating a function call return.
> 
> This is in spite of Halts appearing to do so in your execution traces.
> 
> Halts is invoked via a CALL instruction, which somehow or other
> returns, with the 0 value in EAX.
> 
> Why should anyone accept your stipulation that a CALL which passed
> control back to the calling stack frame has not returned?
> 


-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-10 19:47 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<BCjmI.585555$%W6.276023@fx44.iad>
In reply to#33255
On 5/10/21 9:06 AM, olcott wrote:
> On 5/10/2021 12:41 AM, Kaz Kylheku wrote:
>> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>>> 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()
>>
>> But X corresponds to Halts and that is appearing to return.
>>
> 
> Good catch.
> 
> The rule had to be corrected
> (4) with no function call returns from X()
> was changed to this
> (4) with no function call returns from X() to Y()
> 
> No simulator every returns to the program that it is simulating.

But when Y() [H_Hat] calls X() [Halts] as the actual Turing Machine, and
not a simulation, then Halts DOES need to return to it, just as it
returned to 'main' when it was asked directly.

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 23:02 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<Tm1mI.39313$zx1.4798@fx20.iad>
In reply to#33227
On 5/9/21 9:45 PM, olcott wrote:
> 
> When the execution trace of H_Hat() correctly matches a correct
> non-halting behavior pattern then the decision of non-halting is
> impossibly incorrect.
> 
> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct and
> we know that H_Hat(H_Hat) halts what could explain this?
> 
> 

Hypothetically, you are an idiot.

Imperically, H_Hat(H_Hat) halts, as this trace shows:


On 4/27/21 12:55 AM, olcott wrote:
Message-ID: <Teudndbu59GVBBr9nZ2dnUU7-V2dnZ2d@giganews.com>
> void H_Hat(u32 P)
> {
>  u32 Input_Halts = Halts(P, P);
>  if (Input_Halts)
>    HERE: goto HERE;
> }
>
>
> int main()
> {
>  H_Hat((u32)H_Hat);
> }
>
>
> _H_Hat()
> [00000b98](01)  55                  	push ebp
> [00000b99](02)  8bec                	mov ebp,esp
>
[00000b9b](01)  51                  	push ecx
> [00000b9c](03)  8b4508              	mov eax,[ebp+08]
> [00000b9f](01)  50                  	push eax
> [00000ba0](03)  8b4d08              	mov ecx,[ebp+08]
> [00000ba3](01)  51                  	push ecx
> [00000ba4](05)  e88ffdffff          	call 00000938
> [00000ba9](03)  83c408              	add esp,+08
> [00000bac](03)  8945fc              	mov [ebp-04],eax
> [00000baf](04)  837dfc00            	cmp dword [ebp-04],+00
> [00000bb3](02)  7402                	jz 00000bb7
> [00000bb5](02)  ebfe                	jmp 00000bb5
> [00000bb7](02)  8be5                	mov esp,ebp
> [00000bb9](01)  5d                  	pop ebp
> [00000bba](01)  c3                  	ret
> Size in bytes:(0035) [00000bba]
>
> _main()
> [00000bc8](01)  55                  	push ebp
> [00000bc9](02)  8bec                	mov ebp,esp
> [00000bcb](05)  68980b0000          push 00000b98
> [00000bd0](05)  e8c3ffffff          	call 00000b98
> [00000bd5](03)  83c404              	add esp,+04
> [00000bd8](02)  33c0                	xor eax,eax
> [00000bda](01)  5d                  	pop ebp
> [00000bdb](01)  c3                  	ret
> Size in bytes:(0020) [00000bdb]
>
> ===============================
> ...[00000bc8][001015d4][00000000](01)  55         push ebp
> ...[00000bc9][001015d4][00000000](02)  8bec       mov ebp,esp
> ...[00000bcb][001015d0][00000b98](05)  68980b0000 push 00000b98
> ...[00000bd0][001015cc][00000bd5](05)  e8c3ffffff call 00000b98
> ...[00000b98][001015c8][001015d4](01)  55         push ebp
> ...[00000b99][001015c8][001015d4](02)  8bec       mov ebp,esp
> ...[00000b9b][001015c4][00000000](01)  51         push ecx
> ...[00000b9c][001015c4][00000000](03)  8b4508     mov  eax,[ebp+08]
> ...[00000b9f][001015c0][00000b98](01)  50         push eax
> ...[00000ba0][001015c0][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][001015bc][00000b98](01)  51         push ecx
> ...[00000ba4][001015b8][00000ba9](05)  e88ffdffff call 00000938
> Begin Local Halt Decider Simulation at Machine Address:b98
> ...[00000b98][00211674][00211678](01)  55         push ebp
> ...[00000b99][00211674][00211678](02)  8bec       mov ebp,esp
> ...[00000b9b][00211670][00201644](01)  51         push ecx
> ...[00000b9c][00211670][00201644](03)  8b4508     mov eax,[ebp+08]
> ...[00000b9f][0021166c][00000b98](01)  50         push eax
> ...[00000ba0][0021166c][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][00211668][00000b98](01)  51         push ecx
> ...[00000ba4][00211664][00000ba9](05)  e88ffdffff call 00000938
> ...[00000b98][0025c09c][0025c0a0](01)  55         push ebp
> ...[00000b99][0025c09c][0025c0a0](02)  8bec       mov ebp,esp
> ...[00000b9b][0025c098][0024c06c](01)  51         push ecx
> ...[00000b9c][0025c098][0024c06c](03)  8b4508     mov eax,[ebp+08]
> ...[00000b9f][0025c094][00000b98](01)  50         push eax
> ...[00000ba0][0025c094][00000b98](03)  8b4d08     mov ecx,[ebp+08]
> ...[00000ba3][0025c090][00000b98](01)  51         push ecx
> ...[00000ba4][0025c08c][00000ba9](05)  e88ffdffff call 00000938
> Local Halt Decider: Infinite Recursion Detected Simulation Stopped

Above decision was from the call the Halts inside H_Hat, deciding that
H_Hat(H_Hat) seems to be non-halting, it then returns that answer and is
processed below:

> ...[00000ba9][001015c4][00000000](03)  83c408     add esp,+08
> ...[00000bac][001015c4][00000000](03)  8945fc     mov [ebp-04],eax
> ...[00000baf][001015c4][00000000](04)  837dfc00   cmp dword [ebp-04],+00
> ...[00000bb3][001015c4][00000000](02)  7402       jz 00000bb7
> ...[00000bb7][001015c8][001015d4](02)  8be5       mov esp,ebp
> ...[00000bb9][001015cc][00000bd5](01)  5d         pop ebp
> ...[00000bba][001015d0][00000b98](01)  c3         ret
> ...[00000bd5][001015d4][00000000](03)  83c404     add esp,+04
> ...[00000bd8][001015d4][00000000](02)  33c0       xor eax,eax
> ...[00000bda][001015d8][00100000](01)  5d         pop ebp
> ...[00000bdb][001015dc][00000098](01)  c3         ret

SEE IT HALTED!

> Number_of_User_Instructions(39)
> Number of Instructions Executed(26567)



On 5/7/21 7:21 PM, olcott wrote:
Message-ID: <ofudnRYWdJL4Vgj9nZ2dnUU7-fPNnZ2d@giganews.com>
> When we make sure not to conflate the behavior of the halt decider with
> the behavior of its input then the fact that a computation halts does
> not entail that it is a halting computation.


>

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


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

FromBen Bacarisse <ben.usenet@bsb.me.uk>
Date2021-05-10 02:31 +0100
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<87fsyvwf0m.fsf@bsb.me.uk>
In reply to#33215
olcott <NoOne@NoWhere.com> writes:

> H_Hat(H_Hat) only halts because it is aborted at some point.

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

You:
| OK

Are you retracting that now?

-- 
Ben.

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-09 20:43 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<-4udnVFoic41EgX9nZ2dnUU7-SvNnZ2d@giganews.com>
In reply to#33224
On 5/9/2021 8:31 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
> 
>> H_Hat(H_Hat) only halts because it is aborted at some point.
> 
> Me:
> || (B) Every computation that halts, for whatever reason, is a halting
> ||     computation.
> 
> You:
> | OK
> 
> Are you retracting that now?
> 


When the execution trace of H_Hat() correctly matches a correct
non-halting behavior pattern then the decision of non-halting is
impossibly incorrect.

Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct and 
we know that H_Hat(H_Hat) halts what could explain this?

They are different computations?

-- 
Copyright 2021 Pete Olcott

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

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


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

FromRichard Damon <Richard@Damon-Family.org>
Date2021-05-09 23:08 -0400
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<zs1mI.39315$zx1.12926@fx20.iad>
In reply to#33226
On 5/9/21 9:43 PM, olcott wrote:
> On 5/9/2021 8:31 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>
>> Me:
>> || (B) Every computation that halts, for whatever reason, is a halting
>> ||     computation.
>>
>> You:
>> | OK
>>
>> Are you retracting that now?
>>
> 
> 
> When the execution trace of H_Hat() correctly matches a correct
> non-halting behavior pattern then the decision of non-halting is
> impossibly incorrect.
> 
> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct and
> we know that H_Hat(H_Hat) halts what could explain this?
> 
> They are different computations?
> 

Right, but if H_Hat(H_Hat) halts than Halts(H_Hat, H_Hat) answering
false is the wrong answer, since if H_Hat(H_Hat) halts it is a halting
computation.

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


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

FromKaz Kylheku <563-365-8930@kylheku.com>
Date2021-05-10 05:32 +0000
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<20210509221422.194@kylheku.com>
In reply to#33226
On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
> On 5/9/2021 8:31 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>> 
>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>> 
>> Me:
>> || (B) Every computation that halts, for whatever reason, is a halting
>> ||     computation.
>> 
>> You:
>> | OK
>> 
>> Are you retracting that now?
>> 
>
>
> When the execution trace of H_Hat() correctly matches a correct
> non-halting behavior pattern then the decision of non-halting is
> impossibly incorrect.

Problem is, you only declared it to be matching. It violates your rules
because Halts returns.

But you declared that not to be the case, even though the execution
traces show that a caller like main or H_Hat can invoke Halts by a "CALL
A05" (or whatever address), and that call eventually returns, with EAX
containing 0.

You're asserting, without rational evidence, that in spite of this,
Halts has not halted, and not returned.

It doesn't make any sense.

Furthermore, it has the following problem. Suppose I believe you that
Halts isn't actually returning even though it looks like it is.

Then that means Halts doesn't meet the conditions of the halting proof.
Halts is required by the proof to be a normal function which, if it
stops and yields a value, is deemed to have halted and returned.

Halts must not be any funny entity that /looks/ like it halted by actually
did not.

So this whole thing has taken a strange turn. Execution traces are
suggesting that Halts could well be meeting the conditions of the proof,
but this time you're the one denying it, and arguing against your own
execution traces.

The bottom line is that if you insist that Halts is not a regular
recursive function, your narrative of refuting a proof is dead in the
water.

> Hypothetically when we know that Halts(H_Hat, H_Hat) == 0 is correct and 
> we know that H_Hat(H_Hat) halts what could explain this?

The most plausible, simplest explanation is that that "0 is correct" is
a mistaken belief.

> They are different computations?

That's not above suspicion. If some code is not meeting the conditions
of the proof, then odd results are possible.

Currently, the execution traces from your apparatus are consistent with
something that meets the proof conditions and (unsurprisingly) validates
the proof by producing an incorrect answer.

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

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


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

Fromolcott <NoOne@NoWhere.com>
Date2021-05-10 08:05 -0500
SubjectRe: Halting problem undecidability and infinite recursion (PDF attached)( aborted at some point )
Message-ID<2_qdnSdO99nisgT9nZ2dnUU7-Q3NnZ2d@giganews.com>
In reply to#33249
On 5/10/2021 12:32 AM, Kaz Kylheku wrote:
> On 2021-05-10, olcott <NoOne@NoWhere.com> wrote:
>> On 5/9/2021 8:31 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> H_Hat(H_Hat) only halts because it is aborted at some point.
>>>
>>> Me:
>>> || (B) Every computation that halts, for whatever reason, is a halting
>>> ||     computation.
>>>
>>> You:
>>> | OK
>>>
>>> Are you retracting that now?
>>>
>>
>>
>> When the execution trace of H_Hat() correctly matches a correct
>> non-halting behavior pattern then the decision of non-halting is
>> impossibly incorrect.
> 
> Problem is, you only declared it to be matching. It violates your rules
> because Halts returns.

Good catch.

The rule had to be corrected
(4) with no function call returns from X()
was changed to this
(4) with no function call returns from X() to Y()

No simulator every returns to the program that it is simulating.

**My whole proof is boiled down to as simple as this:**
When the execution trace of H_Hat() correctly matches a correct
non-halting behavior pattern then the decision of non-halting is
necessarily correct.




-- 
Copyright 2021 Pete Olcott

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

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


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

Back to top | Article view | comp.theory


csiph-web