Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

"Lead us in a few words of silent prayer." -- Bill Peterson, former Houston Oiler football coach

devel / comp.theory / Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ]

SubjectAuthor
* Halting problem proofs refuted on the basis of softwareolcott
+- Halting problem proofs refuted on the basis of softwareMr Flibble
`- Halting problem proofs refuted on the basis of softwareRichard Damon

1
Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ]

<ppidncG2cMtZIkz_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=35699&group=comp.theory#35699

  copy link   Newsgroups: comp.lang.c comp.lang.c++ comp.theory sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 15 Jul 2022 14:28:04 -0500
Date: Fri, 15 Jul 2022 14:28:03 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.11.0
Subject: Re: Halting problem proofs refuted on the basis of software
engineering [ establishing my authorship and asserting my copyrights ]
Content-Language: en-US
Newsgroups: comp.lang.c,comp.lang.c++,comp.theory,sci.logic
References: <FcSdnWH56LrW8U3_nZ2dnUU7_8zNnZ2d@giganews.com>
<F6SdnTz0ef3dkEz_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715130620.0000483f@reddwarf.jmc.corp>
<esudnY0OB8EN6kz_nZ2dnUU7_81j4p2d@giganews.com>
<20220715153211.00005430@reddwarf.jmc.corp>
<JeidnSoS1rskH0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715164900.00006bca@reddwarf.jmc.corp>
<N7ednc5HcpwLE0z_nZ2dnUU7_81j4p2d@giganews.com>
<20220715170340.00001838@reddwarf.jmc.corp>
<aZudnWdIoajRAEz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715180822.000061f6@reddwarf.jmc.corp>
<20220715182802.0000170e@reddwarf.jmc.corp>
<2KidnQBTRtnJO0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715184619.00003607@reddwarf.jmc.corp>
<KbSdncHSDus_N0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715190440.00001376@reddwarf.jmc.corp>
<qLGdnfQQtoHfMkz_nZ2dnUU7_83NnZ2d@giganews.com>
<XqqdnZWta5oKL0z_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715194148.00005b14@reddwarf.jmc.corp>
<y6qdnTUA2dGqJ0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715201115.000077ac@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220715201115.000077ac@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ppidncG2cMtZIkz_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 645
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-D5fXXIKPGWxkkCAJ4hP1toEepzTbNHI6/y1zvjJYlz7V66TqStYIS9iCMBvsUEfiikV4MuWjaX4wbNZ!CCD5/m3YM/BXWUyKPy0IA3OiM2QQ6dyISFjxzTZzJ1+MM9mns3bWpfzJEnT+sp54GYOkNwiu2Z5h!EA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 35706
 by: olcott - Fri, 15 Jul 2022 19:28 UTC

On 7/15/2022 2:11 PM, Mr Flibble wrote:
> On Fri, 15 Jul 2022 14:04:22 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 7/15/2022 1:41 PM, Mr Flibble wrote:
>>> On Fri, 15 Jul 2022 13:31:50 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 7/15/2022 1:17 PM, olcott wrote:
>>>>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
>>>>>> On Fri, 15 Jul 2022 12:57:53 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>
>>>>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
>>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
>>>>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new insight
>>>>>>>>>>>>>>>>>>>>>>>>>>>> into the halting problem provided in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> language of software engineering. Technical
>>>>>>>>>>>>>>>>>>>>>>>>>>>> computer science terms are explained using
>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineering terms. No knowledge of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is required.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system (based on an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
>>>>>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem proof counter-examples at the much
>>>>>>>>>>>>>>>>>>>>>>>>>>>> higher level of abstraction of C/x86.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>               int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>               if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>                 HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>               return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>               Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P, P)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input we can see that: (1)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Function H() is called from P(). (2) With
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same arguments to H(). (3) With no
>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions in P preceding its invocation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P cannot
>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. Because H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>> see the same (1)(2)(3) that we see H aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P and rejects P as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>                  In computability theory,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem is the problem of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> determining, from a description of an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> arbitrary computer program and an input,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether the program will finish running, or
>>>>>>>>>>>>>>>>>>>>>>>>>>>> continue to run forever. Alan Turing proved
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in 1936 that a general algorithm to solve
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
>>>>>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>                  For any program H that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> might determine if programs halt, a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "pathological" program P, called with some
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, can pass its own source and its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H and then specifically do the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> opposite of what H predicts P will do. No
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H can exist that handles this case.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
>>>>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
>>>>>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this case
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the above halting problem undecidable input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> template has been refuted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
>>>>>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> an accept or reject state on the basis of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior that is actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by these inputs.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> implements that principle* Every
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that this simulated input would
>>>>>>>>>>>>>>>>>>>>>>>>>>>> never terminate normally, correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of software engineering*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
>>>>>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the HP's
>>>>>>>>>>>>>>>>>>>>>>>>>> "impossible input" template.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
>>>>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
>>>>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting
>>>>>>>>>>>>>>>>>>>>>>>>> is erroneous: you are only doing that because
>>>>>>>>>>>>>>>>>>>>>>>>> your broken solution treats it as "infinite
>>>>>>>>>>>>>>>>>>>>>>>>> recursion". There is no recursion in [Strachey
>>>>>>>>>>>>>>>>>>>>>>>>> 1965] and the HP proofs based on it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the
>>>>>>>>>>>>>>>>>>>>>>>> conventional proofs only because no one ever
>>>>>>>>>>>>>>>>>>>>>>>> previously bothered to fully examine how a
>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider would address these
>>>>>>>>>>>>>>>>>>>>>>>> otherwise "impossible" inputs.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>            "When the simulator detects the call
>>>>>>>>>>>>>>>>>>>>>> to H in P it forks the simulation into a
>>>>>>>>>>>>>>>>>>>>>> non-halting branch"
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this
>>>>>>>>>>>>>>>>>>>>>> overly simplistic criteria gets the wrong
>>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
>>>>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions made
>>>>>>>>>>>>>>>>>>>>> without evidence can be dismissed without
>>>>>>>>>>>>>>>>>>>>> evidence.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of cases
>>>>>>>>>>>>>>>>>>>>> where it gets the wrong answer then it shouldn't
>>>>>>>>>>>>>>>>>>>>> be too hard for to provide ONE case backing up
>>>>>>>>>>>>>>>>>>>>> your claim.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>> Sure:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>> static int count = 3;
>>>>>>>>>>>>>>>>>>>>           count--;
>>>>>>>>>>>>>>>>>>>>           if (!count) goto exit;
>>>>>>>>>>>>>>>>>>>>           int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>           if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>             HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>>>>>>           return;
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>           Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider is
>>>>>>>>>>>>>>>>>>> not recursive in nature: my decider will correctly
>>>>>>>>>>>>>>>>>>> determine that that input is pathological so will
>>>>>>>>>>>>>>>>>>> signal an exception.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above terminates normally so your decider gets
>>>>>>>>>>>>>>>>>> the wrong answer.
>>>>>>>>>>>>>>>>> It is a pathological input so neither halts nor
>>>>>>>>>>>>>>>>> doesn't halt: pathological input is INVALID so the
>>>>>>>>>>>>>>>>> correct "answer" is to signal an exception.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So you don't know how static variables work?
>>>>>>>>>>>>>>>> I am not surprised.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> static int count = 0;
>>>>>>>>>>>>>>>>         if (count++ >= 2) goto exit;
>>>>>>>>>>>>>>>>         int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>         if (Halt_Status)
>>>>>>>>>>>>>>>>           HERE: goto HERE;
>>>>>>>>>>>>>>>> exit:
>>>>>>>>>>>>>>>>         return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>         Output("Input_Halts = ", H(P,P));
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Pm()
>>>>>>>>>>>>>>>> [0000141e](01)  55           push ebp
>>>>>>>>>>>>>>>> [0000141f](02)  8bec         mov ebp,esp
>>>>>>>>>>>>>>>> [00001421](03)  83ec08       sub esp,+08
>>>>>>>>>>>>>>>> [00001424](05)  a100000000   mov eax,[00000000]
>>>>>>>>>>>>>>>> [00001429](03)  8945fc       mov [ebp-04],eax
>>>>>>>>>>>>>>>> [0000142c](06)  8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>>>>> [00001432](03)  83c101       add ecx,+01
>>>>>>>>>>>>>>>> [00001435](06)  890d00000000 mov [00000000],ecx
>>>>>>>>>>>>>>>> [0000143b](04)  837dfc02     cmp dword [ebp-04],+02
>>>>>>>>>>>>>>>> [0000143f](02)  7c02         jl 00001443
>>>>>>>>>>>>>>>> [00001441](02)  eb1b         jmp 0000145e
>>>>>>>>>>>>>>>> [00001443](03)  8b5508       mov edx,[ebp+08]
>>>>>>>>>>>>>>>> [00001446](01)  52           push edx
>>>>>>>>>>>>>>>> [00001447](03)  8b4508       mov eax,[ebp+08]
>>>>>>>>>>>>>>>> [0000144a](01)  50           push eax
>>>>>>>>>>>>>>>> [0000144b](05)  e8defcffff   call 0000112e
>>>>>>>>>>>>>>>> [00001450](03)  83c408       add esp,+08
>>>>>>>>>>>>>>>> [00001453](03)  8945f8       mov [ebp-08],eax
>>>>>>>>>>>>>>>> [00001456](04)  837df800     cmp dword [ebp-08],+00
>>>>>>>>>>>>>>>> [0000145a](02)  7402         jz 0000145e
>>>>>>>>>>>>>>>> [0000145c](02)  ebfe         jmp 0000145c
>>>>>>>>>>>>>>>> [0000145e](02)  8be5         mov esp,ebp
>>>>>>>>>>>>>>>> [00001460](01)  5d           pop ebp
>>>>>>>>>>>>>>>> [00001461](01)  c3           ret
>>>>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _main()
>>>>>>>>>>>>>>>> [0000146e](01)  55           push ebp
>>>>>>>>>>>>>>>> [0000146f](02)  8bec         mov ebp,esp
>>>>>>>>>>>>>>>> [00001471](05)  681e140000   push 0000141e
>>>>>>>>>>>>>>>> [00001476](05)  681e140000   push 0000141e
>>>>>>>>>>>>>>>> [0000147b](05)  e8aefcffff   call 0000112e
>>>>>>>>>>>>>>>> [00001480](03)  83c408       add esp,+08
>>>>>>>>>>>>>>>> [00001483](01)  50           push eax
>>>>>>>>>>>>>>>> [00001484](05)  685f050000   push 0000055f
>>>>>>>>>>>>>>>> [00001489](05)  e820f1ffff   call 000005ae
>>>>>>>>>>>>>>>> [0000148e](03)  83c408       add esp,+08
>>>>>>>>>>>>>>>> [00001491](02)  33c0         xor eax,eax
>>>>>>>>>>>>>>>> [00001493](01)  5d           pop ebp
>>>>>>>>>>>>>>>> [00001494](01)  c3           ret
>>>>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>        machine   stack     stack     machine
>>>>>>>>>>>>>>>> assembly address   address   data      code
>>>>>>>>>>>>>>>> language ========  ========  ========  =========
>>>>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
>>>>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
>>>>>>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
>>>>>>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e] 681e140000
>>>>>>>>>>>>>>>> push 0000141e [0000147b][00102456][00001480]
>>>>>>>>>>>>>>>> e8aefcffff call 0000112e
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:11250e
>>>>>>>>>>>>>>>> Address_of_H:112e
>>>>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55           push ebp
>>>>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec         mov ebp,esp
>>>>>>>>>>>>>>>> [00001421][001124f2][90909090] 83ec08       sub esp,+08
>>>>>>>>>>>>>>>> [00001424][001124f2][90909090] a100000000   mov
>>>>>>>>>>>>>>>> eax,[00000000] [00001429][001124f2][90909090] 8945fc
>>>>>>>>>>>>>>>> mov [ebp-04],eax [0000142c][001124f2][90909090]
>>>>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
>>>>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101       add ecx,+01
>>>>>>>>>>>>>>>> [00001435][001124f2][90909090] 890d00000000 mov
>>>>>>>>>>>>>>>> [00000000],ecx [0000143b][001124f2][90909090] 837dfc02
>>>>>>>>>>>>>>>> cmp dword [ebp-04],+02 [0000143f][001124f2][90909090]
>>>>>>>>>>>>>>>> 7c02 jl 00001443 [00001441][001124f2][90909090] eb1b
>>>>>>>>>>>>>>>>     jmp 0000145e [0000145e][001124fa][001124fe] 8be5
>>>>>>>>>>>>>>>> mov esp,ebp [00001460][001124fe][00001217] 5d
>>>>>>>>>>>>>>>> pop ebp [00001461][00112502][0000141e] c3           ret
>>>>>>>>>>>>>>>> H: End Simulation   Input Terminated Normally
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408       add esp,+08
>>>>>>>>>>>>>>>> [00001483][0010245e][00000001] 50           push eax
>>>>>>>>>>>>>>>> [00001484][0010245a][0000055f] 685f050000   push
>>>>>>>>>>>>>>>> 0000055f [00001489][0010245a][0000055f] e820f1ffff
>>>>>>>>>>>>>>>> call 000005ae Input_Halts = 1
>>>>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408       add esp,+08
>>>>>>>>>>>>>>>> [00001491][00102462][00000000] 33c0         xor eax,eax
>>>>>>>>>>>>>>>> [00001493][00102466][00000018] 5d           pop ebp
>>>>>>>>>>>>>>>> [00001494][0010246a][00000000] c3           ret
>>>>>>>>>>>>>>>> Number of Instructions Executed(1317) == 20 Pages
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> For this particular stack trace I notice that the
>>>>>>>>>>>>>>> function symbol at the top of it is Pm not P which
>>>>>>>>>>>>>>> suggests to me one of two things:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
>>>>>>>>>>>>>> disturb my existing code. When I changed all the Pm
>>>>>>>>>>>>>> references to your name I forgot one.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then I suggest you check the output of compilation/linking
>>>>>>>>>>>>> is actually initializing static variables correctly.  Are
>>>>>>>>>>>>> you even using a linker or are you just executing an
>>>>>>>>>>>>> object file? Static data normally goes into a separate
>>>>>>>>>>>>> data segment during the linking process.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> I haven't used static data in such a long time that I
>>>>>>>>>>>> forgot the compiler does not allocate any space for static
>>>>>>>>>>>> variables unless they have been initialized to a non-zero
>>>>>>>>>>>> value.
>>>>>>>>>>>>
>>>>>>>>>>>> void Pm(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>> static int count = 0x777;
>>>>>>>>>>>>       if (count++ > 0x777) goto exit;
>>>>>>>>>>>>       int Halt_Status = H(x, x);
>>>>>>>>>>>>       if (Halt_Status)
>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>> exit:
>>>>>>>>>>>>       return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>       Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> _Pm()
>>>>>>>>>>>> [00000a1a](01)  55              push ebp
>>>>>>>>>>>> [00000a1b](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00000a1d](03)  83ec08          sub esp,+08
>>>>>>>>>>>> [00000a20](05)  a107030000      mov eax,[00000307]
>>>>>>>>>>>> [00000a25](03)  8945fc          mov [ebp-04],eax
>>>>>>>>>>>> [00000a28](06)  8b0d07030000    mov ecx,[00000307]
>>>>>>>>>>>> [00000a2e](03)  83c101          add ecx,+01
>>>>>>>>>>>> [00000a31](06)  890d07030000    mov [00000307],ecx
>>>>>>>>>>>> [00000a37](07)  817dfc77070000  cmp dword [ebp-04],00000777
>>>>>>>>>>>> [00000a3e](02)  7e02            jng 00000a42
>>>>>>>>>>>> [00000a40](02)  eb1b            jmp 00000a5d
>>>>>>>>>>>> [00000a42](03)  8b5508          mov edx,[ebp+08]
>>>>>>>>>>>> [00000a45](01)  52              push edx
>>>>>>>>>>>> [00000a46](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>> [00000a49](01)  50              push eax
>>>>>>>>>>>> [00000a4a](05)  e8ebfdffff      call 0000083a // call H
>>>>>>>>>>>> [00000a4f](03)  83c408          add esp,+08
>>>>>>>>>>>> [00000a52](03)  8945f8          mov [ebp-08],eax
>>>>>>>>>>>> [00000a55](04)  837df800        cmp dword [ebp-08],+00
>>>>>>>>>>>> [00000a59](02)  7402            jz 00000a5d
>>>>>>>>>>>> [00000a5b](02)  ebfe            jmp 00000a5b
>>>>>>>>>>>> [00000a5d](02)  8be5            mov esp,ebp
>>>>>>>>>>>> [00000a5f](01)  5d              pop ebp
>>>>>>>>>>>> [00000a60](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0071) [00000a60]
>>>>>>>>>>>>
>>>>>>>>>>>> _main()
>>>>>>>>>>>> [00000a6a](01)  55              push ebp
>>>>>>>>>>>> [00000a6b](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [00000a6d](05)  681a0a0000      push 00000a1a // push
>>>>>>>>>>>> address of P [00000a72](05)  681a0a0000      push 00000a1a
>>>>>>>>>>>> // push address of P [00000a77](05)  e8befdffff      call
>>>>>>>>>>>> 0000083a // call H [00000a7c](03)  83c408          add
>>>>>>>>>>>> esp,+08 [00000a7f](01)  50              push eax
>>>>>>>>>>>> [00000a80](05)  680b030000      push 0000030b
>>>>>>>>>>>> [00000a85](05)  e8d0f8ffff      call 0000035a
>>>>>>>>>>>> [00000a8a](03)  83c408          add esp,+08
>>>>>>>>>>>> [00000a8d](02)  33c0            xor eax,eax
>>>>>>>>>>>> [00000a8f](01)  5d              pop ebp
>>>>>>>>>>>> [00000a90](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0039) [00000a90]
>>>>>>>>>>>>
>>>>>>>>>>>>      machine   stack     stack     machine    assembly
>>>>>>>>>>>>      address   address   data      code       language
>>>>>>>>>>>>      ========  ========  ========  =========
>>>>>>>>>>>> ============= ...[00000a6a][0010137b][00000000] 55
>>>>>>>>>>>>      push ebp ...[00000a6b][0010137b][00000000] 8bec
>>>>>>>>>>>>      mov ebp,esp ...[00000a6d][00101377][00000a1a]
>>>>>>>>>>>> 681a0a0000      push 00000a1a
>>>>>>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push 00000a1a
>>>>>>>>>>>> ...[00000a77][0010136f][00000a7c] e8befdffff call 0000083a
>>>>>>>>>>>> New slave_stack at:201427
>>>>>>>>>>>>
>>>>>>>>>>>> Begin Local Halt Decider Simulation   Execution Trace
>>>>>>>>>>>> Stored at:21142f ...[00000a1a][0021141b][0021141f] 55
>>>>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
>>>>>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
>>>>>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090] a107030000
>>>>>>>>>>>>   mov eax,[00000307] ...[00000a25][00211413][90909090]
>>>>>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][00211413][90909090]
>>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
>>>>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
>>>>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
>>>>>>>>>>>> 817dfc77070000  cmp dword [ebp-04],00000777
>>>>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02            jng
>>>>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508
>>>>>>>>>>>> mov edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
>>>>>>>>>>>> edx      // push address of P
>>>>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508          mov
>>>>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push eax
>>>>>>>>>>>>    // push address of P ...[00000a4a][00211407][00000a4f]
>>>>>>>>>>>> e8ebfdffff      call 0000083a // call H New slave_stack
>>>>>>>>>>>> at:24be4f ...[00000a1a][0025be43][0025be47] 55
>>>>>>>>>>>> push ebp ...[00000a1b][0025be43][0025be47] 8bec
>>>>>>>>>>>> mov ebp,esp ...[00000a1d][0025be3b][90909090] 83ec08
>>>>>>>>>>>> sub esp,+08 ...[00000a20][0025be3b][90909090] a107030000
>>>>>>>>>>>>   mov eax,[00000307] ...[00000a25][0025be3b][90909090]
>>>>>>>>>>>> 8945fc mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
>>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
>>>>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
>>>>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
>>>>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
>>>>>>>>>>>> 817dfc77070000  cmp dword [ebp-04],00000777
>>>>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02            jng
>>>>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b
>>>>>>>>>>>> jmp 00000a5d // jmp to exit
>>>>>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5            mov
>>>>>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d
>>>>>>>>>>>> pop ebp ...[00000a60][0025be4b][00000a1a] c3
>>>>>>>>>>>> ret ...[00000a7c][0010137b][00000000] 83c408          add
>>>>>>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50
>>>>>>>>>>>> push eax ...[00000a80][00101373][0000030b] 680b030000
>>>>>>>>>>>> push 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
>>>>>>>>>>>>    call 0000035a Input_Halts = 1
>>>>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408          add
>>>>>>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0
>>>>>>>>>>>> xor eax,eax ...[00000a8f][0010137f][00100000] 5d
>>>>>>>>>>>> pop ebp ...[00000a90][00101383][00000004] c3
>>>>>>>>>>>> ret Number of Instructions Executed(27278)
>>>>>>>>>>>
>>>>>>>>>>> Still seems wrong: post increment of the static variable
>>>>>>>>>>> should ensure that it does NOT goto exit but instead should
>>>>>>>>>>> call H which should presumably cause your "infinite
>>>>>>>>>>> recursion detected" bollocks to manifest.
>>>>>>>>>>
>>>>>>>>>> OK, I've looked at your assembly trace and it is recursing
>>>>>>>>>> into Pm from H and then halting but I am not sure what you
>>>>>>>>>> are trying to prove? Again [Strachey 1965] and associated
>>>>>>>>>> proofs are not recursive in nature.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> (1) H cannot correctly determine the halt status of the HP
>>>>>>>>> counter-examples unless H is a simulating halt decider.
>>>>>>>>>
>>>>>>>>> (2) The claim of the halting problem proofs is that no H in
>>>>>>>>> the universe can possibly correctly determine the halt status
>>>>>>>>> of its corresponding pathological input.
>>>>>>>>>
>>>>>>>>> (3) H(P,P) does correctly determine that its correponding
>>>>>>>>> pathological input would never halt.
>>>>>>>>>
>>>>>>>>> (4) It is ridiculously stupid of you to say that [Strachey
>>>>>>>>> 1965] does not specify infinitely recursive simulation when
>>>>>>>>> it is an easily verified fact that when Strachey T <is> a
>>>>>>>>> simulating halt decider that Strachey P <does> specify
>>>>>>>>> infinitely recursive simulation.
>>>>>>>>>
>>>>>>>>> It does not say this directly in [Strachey 1965] only because
>>>>>>>>> no one ever previously bothered to fully examine the effect
>>>>>>>>> of a simulating halt decider on the HP's pathological inputs.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I see I have to repeat myself yet again: a simulating halt
>>>>>>>> decider needn't be recursive in nature and I have sketched a
>>>>>>>> design of such a halt decider:
>>>>>>>>
>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>>>>>>>
>>>>>>>> You are incorrect to claim an equivalence between pathological
>>>>>>>> input and non-halting.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> 19 When the simulator detects the call to H in P it forks the
>>>>>>> simulation 20 into a non-halting branch (returning 0 to P) and a
>>>>>>> halting branch 21 (returning 1 to P)
>>>>>>>
>>>>>>> Software engineers at the low end of technical competence may
>>>>>>> not fully comprehend the common knowledge that:
>>>>>>>
>>>>>>> Whenever a function is called in what is essentially infinite
>>>>>>> recursion this function cannot possibly correctly return any
>>>>>>> value to its caller. You don't seem to understand that.
>>>>>>
>>>>>> Why are you so fucking obtuse? My forking simulating decider IS
>>>>>> NOT RECURSIVE.
>>>>>
>>>>> It is directly disobeying the actual behavior specified by the
>>>>> actual input by returning a value to a function that called it in
>>>>> infinite recursion.
>>>>>
>>>>>
>>>>
>>>> Even if we did accept that your pathological self-reference
>>>> detector is valid it is only a copycat of my idea and it provides
>>>> a weaker result. It answers: I don't know and mine answers:
>>>> non-halting.
>>>
>>> I could trivially change my decider to return a decision of
>>> non-halting instead of signaling an exception if I believed such a
>>> mapping was correct, but I don't, so I won't.
>>>
>>>>
>>>> Because you did not even copycat my criteria correctly your H gets
>>>> the wrong answer on this input.
>>>>
>>>> int add(int N)
>>>> {
>>>> return N + 3;
>>>> }
>>>>
>>>> void Pc(ptr x)
>>>> {
>>>> H(add, (ptr)7);
>>>> return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(Pc,Pc));
>>>> }
>>>
>>> My decider would correctly answer that Pc halts: passing a different
>>> input to H would be equivalent to the call to H from main(), i.e. it
>>> would be a function call rather than a fork detection: forks only
>>> happen if H is called with the same input more than once.
>>>
>>> /Flibble
>>>
>>
>> https://github.com/i42output/halting-problem/blob/main/README.txt
>>
>> You did not bother to copycat my criteria: "with the same input"
>> therefore your specification fails the above test.
>
> The only thing my decider and your decider have in common is that they
> are both simulating halt deciders.
>
>>
>> When simulating halt decider H(P,P) simulates its input we can see
>> that: (1) Function H() is called from P().
>> (2) With the same arguments to H().
>> (3) With no instructions in P preceding its invocation of H(P,P).
>>
>> As already shown before you also did not bother to copycat my
>> criteria (3) which provides another escape route from non-termination.
>>
>> When you add these crriteria I insist on a reference to my copyright
>> notice for these criteria.
>>
>> *Halting problem proofs refuted on the basis of software engineering*
>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
>
> No. You cannot copyright the idea of a simulating halt decider; you only
> have a copyright for your broken simulating halt decider.
>
> /Flibble
>


Click here to read the complete article
Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ]

<20220715203358.00004649@reddwarf.jmc.corp>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=35700&group=comp.theory#35700

  copy link   Newsgroups: comp.lang.c comp.lang.c++ comp.theory sci.logic
Path: i2pn2.org!rocksolid2!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.lang.c,comp.lang.c++,comp.theory,sci.logic
Subject: Re: Halting problem proofs refuted on the basis of software
engineering [ establishing my authorship and asserting my copyrights ]
Message-ID: <20220715203358.00004649@reddwarf.jmc.corp>
References: <FcSdnWH56LrW8U3_nZ2dnUU7_8zNnZ2d@giganews.com>
<esudnY0OB8EN6kz_nZ2dnUU7_81j4p2d@giganews.com>
<20220715153211.00005430@reddwarf.jmc.corp>
<JeidnSoS1rskH0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715164900.00006bca@reddwarf.jmc.corp>
<N7ednc5HcpwLE0z_nZ2dnUU7_81j4p2d@giganews.com>
<20220715170340.00001838@reddwarf.jmc.corp>
<aZudnWdIoajRAEz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715180822.000061f6@reddwarf.jmc.corp>
<20220715182802.0000170e@reddwarf.jmc.corp>
<2KidnQBTRtnJO0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715184619.00003607@reddwarf.jmc.corp>
<KbSdncHSDus_N0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715190440.00001376@reddwarf.jmc.corp>
<qLGdnfQQtoHfMkz_nZ2dnUU7_83NnZ2d@giganews.com>
<XqqdnZWta5oKL0z_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715194148.00005b14@reddwarf.jmc.corp>
<y6qdnTUA2dGqJ0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715201115.000077ac@reddwarf.jmc.corp>
<ppidncG2cMtZIkz_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Lines: 764
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Fri, 15 Jul 2022 19:33:59 UTC
Date: Fri, 15 Jul 2022 20:33:58 +0100
X-Received-Bytes: 38937
 by: Mr Flibble - Fri, 15 Jul 2022 19:33 UTC

On Fri, 15 Jul 2022 14:28:03 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 7/15/2022 2:11 PM, Mr Flibble wrote:
> > On Fri, 15 Jul 2022 14:04:22 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 7/15/2022 1:41 PM, Mr Flibble wrote:
> >>> On Fri, 15 Jul 2022 13:31:50 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 7/15/2022 1:17 PM, olcott wrote:
> >>>>> On 7/15/2022 1:04 PM, Mr Flibble wrote:
> >>>>>> On Fri, 15 Jul 2022 12:57:53 -0500
> >>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>
> >>>>>>> On 7/15/2022 12:46 PM, Mr Flibble wrote:
> >>>>>>>> On Fri, 15 Jul 2022 12:39:31 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>> On 7/15/2022 12:28 PM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 15 Jul 2022 18:08:22 +0100
> >>>>>>>>>> Mr Flibble <flibble@reddwarf.jmc.corp> wrote:
> >>>>>>>>>>> On Fri, 15 Jul 2022 12:00:59 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> On 7/15/2022 11:03 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Fri, 15 Jul 2022 10:58:14 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>> On 7/15/2022 10:49 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> On Fri, 15 Jul 2022 10:07:36 -0500
> >>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>> On 7/15/2022 9:32 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 09:19:59 -0500
> >>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>> On 7/15/2022 7:06 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>> On Fri, 15 Jul 2022 01:46:23 -0500
> >>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>> On 7/15/2022 1:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 17:41:06 -0500
> >>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 5:30 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 16:02:35 -0500
> >>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 3:22 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 15:02:21 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 7/14/2022 2:28 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Thu, 14 Jul 2022 14:19:38 -0500
> >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> This is an explanation of a key new
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> insight into the halting problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> provided in the language of software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering. Technical computer science
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> terms are explained using software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering terms. No knowledge of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem is required.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> It is based on fully operational software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> executed in the x86utm operating system.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The x86utm operating system (based on an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> excellent open source x86 emulator) was
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> created to study the details of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem proof counter-examples
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> at the much higher level of abstraction
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> of C/x86.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> typedef void (*ptr)();
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int H(ptr p, ptr i); // simulating halt
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>               int Halt_Status = H(x,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> x); if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>                 HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>               return;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>               Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P, P)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> When simulating halt decider H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input we can see that: (1)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Function H() is called from P(). (2) With
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the same arguments to H(). (3) With no
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions in P preceding its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> invocation of H(P,P).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> The above shows that the simulated P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly terminate normally.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Because H can see the same (1)(2)(3)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that we see H aborts its simulation of P
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> and rejects P as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>                  In computability
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> theory, the halting problem is the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem of determining, from a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> description of an arbitrary computer
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> program and an input, whether the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> program will finish running, or continue
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to run forever. Alan Turing proved in
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> 1936 that a general algorithm to solve
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem for all possible
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> program- input pairs cannot exist.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>                  For any program H that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> might determine if programs halt, a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> "pathological" program P, called with
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> some input, can pass its own source and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> its input to H and then specifically do
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> the opposite of what H predicts P will
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> do. No H can exist that handles this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> case.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H and P implement the exact pathological
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> relationship to each other as described
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> above. Because H(P,P) does handle this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> case the above halting problem
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> undecidable input template has been
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> refuted.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *When this halt deciding principle
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> understood to be correct* A halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> must compute the mapping from its inputs
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> to an accept or reject state on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of the actual behavior that is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> actually specified by these inputs.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *Then (by logical necessity) this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> implements that principle* Every
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider that correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until it correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> predicts that this simulated input would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> never terminate normally, correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> rejects this input as non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *H is a Pure function*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Pure_function
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> thus implements a *Computable function*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Computable_function
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Thus H is Turing computable.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> *Halting problem proofs refuted on the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of software engineering*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> You forgot to mention infinite recursion
> >>>>>>>>>>>>>>>>>>>>>>>>>>> which I suppose is progress.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have proved that H(P,P) == 0 is correct.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> I have shown that H/P does implement the
> >>>>>>>>>>>>>>>>>>>>>>>>>> HP's "impossible input" template.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> Therefore I have refuted all of the halting
> >>>>>>>>>>>>>>>>>>>>>>>>>> problem proofs that rely on this template.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> Equating pathological input with non-halting
> >>>>>>>>>>>>>>>>>>>>>>>>> is erroneous: you are only doing that
> >>>>>>>>>>>>>>>>>>>>>>>>> because your broken solution treats it as
> >>>>>>>>>>>>>>>>>>>>>>>>> "infinite recursion". There is no recursion
> >>>>>>>>>>>>>>>>>>>>>>>>> in [Strachey 1965] and the HP proofs based
> >>>>>>>>>>>>>>>>>>>>>>>>> on it.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> There is no recursion in any of the
> >>>>>>>>>>>>>>>>>>>>>>>> conventional proofs only because no one ever
> >>>>>>>>>>>>>>>>>>>>>>>> previously bothered to fully examine how a
> >>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider would address these
> >>>>>>>>>>>>>>>>>>>>>>>> otherwise "impossible" inputs.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> I have shown that a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>> needn't be recursive in nature:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> You sure do make it easy to review your work.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>            "When the simulator detects the
> >>>>>>>>>>>>>>>>>>>>>> call to H in P it forks the simulation into a
> >>>>>>>>>>>>>>>>>>>>>> non-halting branch"
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> There is an infinite set of cases where this
> >>>>>>>>>>>>>>>>>>>>>> overly simplistic criteria gets the wrong
> >>>>>>>>>>>>>>>>>>>>>> answer.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> That is neither an honest review or any kind of
> >>>>>>>>>>>>>>>>>>>>> rebuttal: I have told you before: assertions
> >>>>>>>>>>>>>>>>>>>>> made without evidence can be dismissed without
> >>>>>>>>>>>>>>>>>>>>> evidence.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> If you claim there are an infinite number of
> >>>>>>>>>>>>>>>>>>>>> cases where it gets the wrong answer then it
> >>>>>>>>>>>>>>>>>>>>> shouldn't be too hard for to provide ONE case
> >>>>>>>>>>>>>>>>>>>>> backing up your claim.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>> Sure:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> static int count = 3;
> >>>>>>>>>>>>>>>>>>>>           count--;
> >>>>>>>>>>>>>>>>>>>>           if (!count) goto exit;
> >>>>>>>>>>>>>>>>>>>>           int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>>>>>           if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>             HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>>>>>>           return;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>           Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>> Nope; you seem to have forgotten that my decider
> >>>>>>>>>>>>>>>>>>> is not recursive in nature: my decider will
> >>>>>>>>>>>>>>>>>>> correctly determine that that input is
> >>>>>>>>>>>>>>>>>>> pathological so will signal an exception.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> The above terminates normally so your decider gets
> >>>>>>>>>>>>>>>>>> the wrong answer.
> >>>>>>>>>>>>>>>>> It is a pathological input so neither halts nor
> >>>>>>>>>>>>>>>>> doesn't halt: pathological input is INVALID so the
> >>>>>>>>>>>>>>>>> correct "answer" is to signal an exception.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So you don't know how static variables work?
> >>>>>>>>>>>>>>>> I am not surprised.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>> static int count = 0;
> >>>>>>>>>>>>>>>>         if (count++ >= 2) goto exit;
> >>>>>>>>>>>>>>>>         int Halt_Status = H(x, x);
> >>>>>>>>>>>>>>>>         if (Halt_Status)
> >>>>>>>>>>>>>>>>           HERE: goto HERE;
> >>>>>>>>>>>>>>>> exit:
> >>>>>>>>>>>>>>>>         return;
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>         Output("Input_Halts = ", H(P,P));
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _Pm()
> >>>>>>>>>>>>>>>> [0000141e](01)  55           push ebp
> >>>>>>>>>>>>>>>> [0000141f](02)  8bec         mov ebp,esp
> >>>>>>>>>>>>>>>> [00001421](03)  83ec08       sub esp,+08
> >>>>>>>>>>>>>>>> [00001424](05)  a100000000   mov eax,[00000000]
> >>>>>>>>>>>>>>>> [00001429](03)  8945fc       mov [ebp-04],eax
> >>>>>>>>>>>>>>>> [0000142c](06)  8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>>>>> [00001432](03)  83c101       add ecx,+01
> >>>>>>>>>>>>>>>> [00001435](06)  890d00000000 mov [00000000],ecx
> >>>>>>>>>>>>>>>> [0000143b](04)  837dfc02     cmp dword [ebp-04],+02
> >>>>>>>>>>>>>>>> [0000143f](02)  7c02         jl 00001443
> >>>>>>>>>>>>>>>> [00001441](02)  eb1b         jmp 0000145e
> >>>>>>>>>>>>>>>> [00001443](03)  8b5508       mov edx,[ebp+08]
> >>>>>>>>>>>>>>>> [00001446](01)  52           push edx
> >>>>>>>>>>>>>>>> [00001447](03)  8b4508       mov eax,[ebp+08]
> >>>>>>>>>>>>>>>> [0000144a](01)  50           push eax
> >>>>>>>>>>>>>>>> [0000144b](05)  e8defcffff   call 0000112e
> >>>>>>>>>>>>>>>> [00001450](03)  83c408       add esp,+08
> >>>>>>>>>>>>>>>> [00001453](03)  8945f8       mov [ebp-08],eax
> >>>>>>>>>>>>>>>> [00001456](04)  837df800     cmp dword [ebp-08],+00
> >>>>>>>>>>>>>>>> [0000145a](02)  7402         jz 0000145e
> >>>>>>>>>>>>>>>> [0000145c](02)  ebfe         jmp 0000145c
> >>>>>>>>>>>>>>>> [0000145e](02)  8be5         mov esp,ebp
> >>>>>>>>>>>>>>>> [00001460](01)  5d           pop ebp
> >>>>>>>>>>>>>>>> [00001461](01)  c3           ret
> >>>>>>>>>>>>>>>> Size in bytes:(0068) [00001461]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> _main()
> >>>>>>>>>>>>>>>> [0000146e](01)  55           push ebp
> >>>>>>>>>>>>>>>> [0000146f](02)  8bec         mov ebp,esp
> >>>>>>>>>>>>>>>> [00001471](05)  681e140000   push 0000141e
> >>>>>>>>>>>>>>>> [00001476](05)  681e140000   push 0000141e
> >>>>>>>>>>>>>>>> [0000147b](05)  e8aefcffff   call 0000112e
> >>>>>>>>>>>>>>>> [00001480](03)  83c408       add esp,+08
> >>>>>>>>>>>>>>>> [00001483](01)  50           push eax
> >>>>>>>>>>>>>>>> [00001484](05)  685f050000   push 0000055f
> >>>>>>>>>>>>>>>> [00001489](05)  e820f1ffff   call 000005ae
> >>>>>>>>>>>>>>>> [0000148e](03)  83c408       add esp,+08
> >>>>>>>>>>>>>>>> [00001491](02)  33c0         xor eax,eax
> >>>>>>>>>>>>>>>> [00001493](01)  5d           pop ebp
> >>>>>>>>>>>>>>>> [00001494](01)  c3           ret
> >>>>>>>>>>>>>>>> Size in bytes:(0039) [00001494]
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>        machine   stack     stack     machine
> >>>>>>>>>>>>>>>> assembly address   address   data      code
> >>>>>>>>>>>>>>>> language ========  ========  ========  ========> >>>>>>>>>>>>>>>> ============= [0000146e][00102462][00000000] 55
> >>>>>>>>>>>>>>>> push ebp [0000146f][00102462][00000000] 8bec
> >>>>>>>>>>>>>>>> mov ebp,esp [00001471][0010245e][0000141e] 681e140000
> >>>>>>>>>>>>>>>> push 0000141e [00001476][0010245a][0000141e]
> >>>>>>>>>>>>>>>> 681e140000 push 0000141e
> >>>>>>>>>>>>>>>> [0000147b][00102456][00001480] e8aefcffff call
> >>>>>>>>>>>>>>>> 0000112e
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored
> >>>>>>>>>>>>>>>> at:11250e Address_of_H:112e
> >>>>>>>>>>>>>>>> [0000141e][001124fa][001124fe] 55           push ebp
> >>>>>>>>>>>>>>>> [0000141f][001124fa][001124fe] 8bec         mov
> >>>>>>>>>>>>>>>> ebp,esp [00001421][001124f2][90909090] 83ec08
> >>>>>>>>>>>>>>>> sub esp,+08 [00001424][001124f2][90909090]
> >>>>>>>>>>>>>>>> a100000000   mov eax,[00000000]
> >>>>>>>>>>>>>>>> [00001429][001124f2][90909090] 8945fc mov
> >>>>>>>>>>>>>>>> [ebp-04],eax [0000142c][001124f2][90909090]
> >>>>>>>>>>>>>>>> 8b0d00000000 mov ecx,[00000000]
> >>>>>>>>>>>>>>>> [00001432][001124f2][90909090] 83c101       add
> >>>>>>>>>>>>>>>> ecx,+01 [00001435][001124f2][90909090] 890d00000000
> >>>>>>>>>>>>>>>> mov [00000000],ecx [0000143b][001124f2][90909090]
> >>>>>>>>>>>>>>>> 837dfc02 cmp dword [ebp-04],+02
> >>>>>>>>>>>>>>>> [0000143f][001124f2][90909090] 7c02 jl 00001443
> >>>>>>>>>>>>>>>> [00001441][001124f2][90909090] eb1b jmp 0000145e
> >>>>>>>>>>>>>>>> [0000145e][001124fa][001124fe] 8be5 mov esp,ebp
> >>>>>>>>>>>>>>>> [00001460][001124fe][00001217] 5d pop ebp
> >>>>>>>>>>>>>>>> [00001461][00112502][0000141e] c3           ret H:
> >>>>>>>>>>>>>>>> End Simulation   Input Terminated Normally
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> [00001480][00102462][00000000] 83c408       add
> >>>>>>>>>>>>>>>> esp,+08 [00001483][0010245e][00000001] 50
> >>>>>>>>>>>>>>>> push eax [00001484][0010245a][0000055f] 685f050000
> >>>>>>>>>>>>>>>> push 0000055f [00001489][0010245a][0000055f]
> >>>>>>>>>>>>>>>> e820f1ffff call 000005ae Input_Halts = 1
> >>>>>>>>>>>>>>>> [0000148e][00102462][00000000] 83c408       add
> >>>>>>>>>>>>>>>> esp,+08 [00001491][00102462][00000000] 33c0
> >>>>>>>>>>>>>>>> xor eax,eax [00001493][00102466][00000018] 5d
> >>>>>>>>>>>>>>>>    pop ebp [00001494][0010246a][00000000] c3
> >>>>>>>>>>>>>>>>   ret Number of Instructions Executed(1317) == 20
> >>>>>>>>>>>>>>>> Pages
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> For this particular stack trace I notice that the
> >>>>>>>>>>>>>>> function symbol at the top of it is Pm not P which
> >>>>>>>>>>>>>>> suggests to me one of two things:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I already had a P so I renamed it to Pm so it would not
> >>>>>>>>>>>>>> disturb my existing code. When I changed all the Pm
> >>>>>>>>>>>>>> references to your name I forgot one.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Then I suggest you check the output of
> >>>>>>>>>>>>> compilation/linking is actually initializing static
> >>>>>>>>>>>>> variables correctly.  Are you even using a linker or
> >>>>>>>>>>>>> are you just executing an object file? Static data
> >>>>>>>>>>>>> normally goes into a separate data segment during the
> >>>>>>>>>>>>> linking process.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> I haven't used static data in such a long time that I
> >>>>>>>>>>>> forgot the compiler does not allocate any space for
> >>>>>>>>>>>> static variables unless they have been initialized to a
> >>>>>>>>>>>> non-zero value.
> >>>>>>>>>>>>
> >>>>>>>>>>>> void Pm(u32 x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>> static int count = 0x777;
> >>>>>>>>>>>>       if (count++ > 0x777) goto exit;
> >>>>>>>>>>>>       int Halt_Status = H(x, x);
> >>>>>>>>>>>>       if (Halt_Status)
> >>>>>>>>>>>>         HERE: goto HERE;
> >>>>>>>>>>>> exit:
> >>>>>>>>>>>>       return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> int main()
> >>>>>>>>>>>> {
> >>>>>>>>>>>>       Output("Input_Halts = ", H((u32)Pm, (u32)Pm));
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> _Pm()
> >>>>>>>>>>>> [00000a1a](01)  55              push ebp
> >>>>>>>>>>>> [00000a1b](02)  8bec            mov ebp,esp
> >>>>>>>>>>>> [00000a1d](03)  83ec08          sub esp,+08
> >>>>>>>>>>>> [00000a20](05)  a107030000      mov eax,[00000307]
> >>>>>>>>>>>> [00000a25](03)  8945fc          mov [ebp-04],eax
> >>>>>>>>>>>> [00000a28](06)  8b0d07030000    mov ecx,[00000307]
> >>>>>>>>>>>> [00000a2e](03)  83c101          add ecx,+01
> >>>>>>>>>>>> [00000a31](06)  890d07030000    mov [00000307],ecx
> >>>>>>>>>>>> [00000a37](07)  817dfc77070000  cmp dword
> >>>>>>>>>>>> [ebp-04],00000777 [00000a3e](02)  7e02            jng
> >>>>>>>>>>>> 00000a42 [00000a40](02)  eb1b            jmp 00000a5d
> >>>>>>>>>>>> [00000a42](03)  8b5508          mov edx,[ebp+08]
> >>>>>>>>>>>> [00000a45](01)  52              push edx
> >>>>>>>>>>>> [00000a46](03)  8b4508          mov eax,[ebp+08]
> >>>>>>>>>>>> [00000a49](01)  50              push eax
> >>>>>>>>>>>> [00000a4a](05)  e8ebfdffff      call 0000083a // call H
> >>>>>>>>>>>> [00000a4f](03)  83c408          add esp,+08
> >>>>>>>>>>>> [00000a52](03)  8945f8          mov [ebp-08],eax
> >>>>>>>>>>>> [00000a55](04)  837df800        cmp dword [ebp-08],+00
> >>>>>>>>>>>> [00000a59](02)  7402            jz 00000a5d
> >>>>>>>>>>>> [00000a5b](02)  ebfe            jmp 00000a5b
> >>>>>>>>>>>> [00000a5d](02)  8be5            mov esp,ebp
> >>>>>>>>>>>> [00000a5f](01)  5d              pop ebp
> >>>>>>>>>>>> [00000a60](01)  c3              ret
> >>>>>>>>>>>> Size in bytes:(0071) [00000a60]
> >>>>>>>>>>>>
> >>>>>>>>>>>> _main()
> >>>>>>>>>>>> [00000a6a](01)  55              push ebp
> >>>>>>>>>>>> [00000a6b](02)  8bec            mov ebp,esp
> >>>>>>>>>>>> [00000a6d](05)  681a0a0000      push 00000a1a // push
> >>>>>>>>>>>> address of P [00000a72](05)  681a0a0000      push
> >>>>>>>>>>>> 00000a1a // push address of P [00000a77](05)  e8befdffff
> >>>>>>>>>>>>      call 0000083a // call H [00000a7c](03)  83c408
> >>>>>>>>>>>>     add esp,+08 [00000a7f](01)  50              push eax
> >>>>>>>>>>>> [00000a80](05)  680b030000      push 0000030b
> >>>>>>>>>>>> [00000a85](05)  e8d0f8ffff      call 0000035a
> >>>>>>>>>>>> [00000a8a](03)  83c408          add esp,+08
> >>>>>>>>>>>> [00000a8d](02)  33c0            xor eax,eax
> >>>>>>>>>>>> [00000a8f](01)  5d              pop ebp
> >>>>>>>>>>>> [00000a90](01)  c3              ret
> >>>>>>>>>>>> Size in bytes:(0039) [00000a90]
> >>>>>>>>>>>>
> >>>>>>>>>>>>      machine   stack     stack     machine    assembly
> >>>>>>>>>>>>      address   address   data      code       language
> >>>>>>>>>>>>      ========  ========  ========  ========> >>>>>>>>>>>> ============= ...[00000a6a][0010137b][00000000] 55
> >>>>>>>>>>>>      push ebp ...[00000a6b][0010137b][00000000] 8bec
> >>>>>>>>>>>>      mov ebp,esp ...[00000a6d][00101377][00000a1a]
> >>>>>>>>>>>> 681a0a0000      push 00000a1a
> >>>>>>>>>>>> ...[00000a72][00101373][00000a1a] 681a0a0000 push
> >>>>>>>>>>>> 00000a1a ...[00000a77][0010136f][00000a7c] e8befdffff
> >>>>>>>>>>>> call 0000083a New slave_stack at:201427
> >>>>>>>>>>>>
> >>>>>>>>>>>> Begin Local Halt Decider Simulation   Execution Trace
> >>>>>>>>>>>> Stored at:21142f ...[00000a1a][0021141b][0021141f] 55
> >>>>>>>>>>>> push ebp ...[00000a1b][0021141b][0021141f] 8bec
> >>>>>>>>>>>> mov ebp,esp ...[00000a1d][00211413][90909090] 83ec08
> >>>>>>>>>>>> sub esp,+08 ...[00000a20][00211413][90909090]
> >>>>>>>>>>>> a107030000 mov eax,[00000307]
> >>>>>>>>>>>> ...[00000a25][00211413][90909090] 8945fc mov
> >>>>>>>>>>>> [ebp-04],eax ...[00000a28][00211413][90909090]
> >>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>>>> ...[00000a2e][00211413][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>> ...[00000a31][00211413][90909090] 890d07030000 mov
> >>>>>>>>>>>> [00000307],ecx ...[00000a37][00211413][90909090]
> >>>>>>>>>>>> 817dfc77070000  cmp dword [ebp-04],00000777
> >>>>>>>>>>>> ...[00000a3e][00211413][90909090] 7e02            jng
> >>>>>>>>>>>> 00000a42 ...[00000a42][00211413][90909090] 8b5508 mov
> >>>>>>>>>>>> edx,[ebp+08] ...[00000a45][0021140f][00000a1a] 52 push
> >>>>>>>>>>>> edx      // push address of P
> >>>>>>>>>>>> ...[00000a46][0021140f][00000a1a] 8b4508          mov
> >>>>>>>>>>>> eax,[ebp+08] ...[00000a49][0021140b][00000a1a] 50 push
> >>>>>>>>>>>> eax // push address of P
> >>>>>>>>>>>> ...[00000a4a][00211407][00000a4f] e8ebfdffff      call
> >>>>>>>>>>>> 0000083a // call H New slave_stack at:24be4f
> >>>>>>>>>>>> ...[00000a1a][0025be43][0025be47] 55 push ebp
> >>>>>>>>>>>> ...[00000a1b][0025be43][0025be47] 8bec mov ebp,esp
> >>>>>>>>>>>> ...[00000a1d][0025be3b][90909090] 83ec08 sub esp,+08
> >>>>>>>>>>>> ...[00000a20][0025be3b][90909090] a107030000 mov
> >>>>>>>>>>>> eax,[00000307] ...[00000a25][0025be3b][90909090] 8945fc
> >>>>>>>>>>>> mov [ebp-04],eax ...[00000a28][0025be3b][90909090]
> >>>>>>>>>>>> 8b0d07030000 mov ecx,[00000307]
> >>>>>>>>>>>> ...[00000a2e][0025be3b][90909090] 83c101 add ecx,+01
> >>>>>>>>>>>> ...[00000a31][0025be3b][90909090] 890d07030000 mov
> >>>>>>>>>>>> [00000307],ecx ...[00000a37][0025be3b][90909090]
> >>>>>>>>>>>> 817dfc77070000  cmp dword [ebp-04],00000777
> >>>>>>>>>>>> ...[00000a3e][0025be3b][90909090] 7e02            jng
> >>>>>>>>>>>> 00000a42 ...[00000a40][0025be3b][90909090] eb1b jmp
> >>>>>>>>>>>> 00000a5d // jmp to exit
> >>>>>>>>>>>> ...[00000a5d][0025be43][0025be47] 8be5            mov
> >>>>>>>>>>>> esp,ebp ...[00000a5f][0025be47][00000904] 5d pop ebp
> >>>>>>>>>>>> ...[00000a60][0025be4b][00000a1a] c3 ret
> >>>>>>>>>>>> ...[00000a7c][0010137b][00000000] 83c408          add
> >>>>>>>>>>>> esp,+08 ...[00000a7f][00101377][00000001] 50 push eax
> >>>>>>>>>>>> ...[00000a80][00101373][0000030b] 680b030000 push
> >>>>>>>>>>>> 0000030b ---[00000a85][00101373][0000030b] e8d0f8ffff
> >>>>>>>>>>>> call 0000035a Input_Halts = 1
> >>>>>>>>>>>> ...[00000a8a][0010137b][00000000] 83c408          add
> >>>>>>>>>>>> esp,+08 ...[00000a8d][0010137b][00000000] 33c0 xor
> >>>>>>>>>>>> eax,eax ...[00000a8f][0010137f][00100000] 5d pop ebp
> >>>>>>>>>>>> ...[00000a90][00101383][00000004] c3 ret Number of
> >>>>>>>>>>>> Instructions Executed(27278)
> >>>>>>>>>>>
> >>>>>>>>>>> Still seems wrong: post increment of the static variable
> >>>>>>>>>>> should ensure that it does NOT goto exit but instead
> >>>>>>>>>>> should call H which should presumably cause your "infinite
> >>>>>>>>>>> recursion detected" bollocks to manifest.
> >>>>>>>>>>
> >>>>>>>>>> OK, I've looked at your assembly trace and it is recursing
> >>>>>>>>>> into Pm from H and then halting but I am not sure what you
> >>>>>>>>>> are trying to prove? Again [Strachey 1965] and associated
> >>>>>>>>>> proofs are not recursive in nature.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>> (1) H cannot correctly determine the halt status of the HP
> >>>>>>>>> counter-examples unless H is a simulating halt decider.
> >>>>>>>>>
> >>>>>>>>> (2) The claim of the halting problem proofs is that no H in
> >>>>>>>>> the universe can possibly correctly determine the halt
> >>>>>>>>> status of its corresponding pathological input.
> >>>>>>>>>
> >>>>>>>>> (3) H(P,P) does correctly determine that its correponding
> >>>>>>>>> pathological input would never halt.
> >>>>>>>>>
> >>>>>>>>> (4) It is ridiculously stupid of you to say that [Strachey
> >>>>>>>>> 1965] does not specify infinitely recursive simulation when
> >>>>>>>>> it is an easily verified fact that when Strachey T <is> a
> >>>>>>>>> simulating halt decider that Strachey P <does> specify
> >>>>>>>>> infinitely recursive simulation.
> >>>>>>>>>
> >>>>>>>>> It does not say this directly in [Strachey 1965] only
> >>>>>>>>> because no one ever previously bothered to fully examine
> >>>>>>>>> the effect of a simulating halt decider on the HP's
> >>>>>>>>> pathological inputs.
> >>>>>>>>
> >>>>>>>> I see I have to repeat myself yet again: a simulating halt
> >>>>>>>> decider needn't be recursive in nature and I have sketched a
> >>>>>>>> design of such a halt decider:
> >>>>>>>>
> >>>>>>>> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>>>>>>>
> >>>>>>>> You are incorrect to claim an equivalence between
> >>>>>>>> pathological input and non-halting.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>
> >>>>>>> 19 When the simulator detects the call to H in P it forks the
> >>>>>>> simulation 20 into a non-halting branch (returning 0 to P)
> >>>>>>> and a halting branch 21 (returning 1 to P)
> >>>>>>>
> >>>>>>> Software engineers at the low end of technical competence may
> >>>>>>> not fully comprehend the common knowledge that:
> >>>>>>>
> >>>>>>> Whenever a function is called in what is essentially infinite
> >>>>>>> recursion this function cannot possibly correctly return any
> >>>>>>> value to its caller. You don't seem to understand that.
> >>>>>>
> >>>>>> Why are you so fucking obtuse? My forking simulating decider IS
> >>>>>> NOT RECURSIVE.
> >>>>>
> >>>>> It is directly disobeying the actual behavior specified by the
> >>>>> actual input by returning a value to a function that called it
> >>>>> in infinite recursion.
> >>>>>
> >>>>>
> >>>>
> >>>> Even if we did accept that your pathological self-reference
> >>>> detector is valid it is only a copycat of my idea and it provides
> >>>> a weaker result. It answers: I don't know and mine answers:
> >>>> non-halting.
> >>>
> >>> I could trivially change my decider to return a decision of
> >>> non-halting instead of signaling an exception if I believed such a
> >>> mapping was correct, but I don't, so I won't.
> >>>
> >>>>
> >>>> Because you did not even copycat my criteria correctly your H
> >>>> gets the wrong answer on this input.
> >>>>
> >>>> int add(int N)
> >>>> {
> >>>> return N + 3;
> >>>> }
> >>>>
> >>>> void Pc(ptr x)
> >>>> {
> >>>> H(add, (ptr)7);
> >>>> return;
> >>>> }
> >>>>
> >>>> int main()
> >>>> {
> >>>> Output("Input_Halts = ", H(Pc,Pc));
> >>>> }
> >>>
> >>> My decider would correctly answer that Pc halts: passing a
> >>> different input to H would be equivalent to the call to H from
> >>> main(), i.e. it would be a function call rather than a fork
> >>> detection: forks only happen if H is called with the same input
> >>> more than once.
> >>>
> >>> /Flibble
> >>>
> >>
> >> https://github.com/i42output/halting-problem/blob/main/README.txt
> >>
> >> You did not bother to copycat my criteria: "with the same input"
> >> therefore your specification fails the above test.
> >
> > The only thing my decider and your decider have in common is that
> > they are both simulating halt deciders.
> >
> >>
> >> When simulating halt decider H(P,P) simulates its input we can see
> >> that: (1) Function H() is called from P().
> >> (2) With the same arguments to H().
> >> (3) With no instructions in P preceding its invocation of H(P,P).
> >>
> >> As already shown before you also did not bother to copycat my
> >> criteria (3) which provides another escape route from
> >> non-termination.
> >>
> >> When you add these crriteria I insist on a reference to my
> >> copyright notice for these criteria.
> >>
> >> *Halting problem proofs refuted on the basis of software
> >> engineering*
> >> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering
> >>
> >
> > No. You cannot copyright the idea of a simulating halt decider; you
> > only have a copyright for your broken simulating halt decider.
> >
> > /Flibble
> >
>
> *I have a copyright on these words and every precise paraphrase*
>
> When simulating halt decider H(P,P) simulates its input we can see
> that: (1) Function H() is called from P().
> (2) With the same arguments to H().
> (3) With no instructions in P preceding its invocation of H(P,P).
>
> https://en.wikipedia.org/wiki/Paraphrasing_of_copyrighted_material
>
> You are expressing using (1)
> "When the simulator detects the call to H in P"
> https://github.com/i42output/halting-problem/blob/main/README.txt
>
> have referred to (2) after the fact when I pointed out that it was
> missing from your spec
>
> On 7/15/2022 1:41 PM, Mr Flibble wrote:
> > ... if H is called with the same input more than once.
>
> and have not bothered to correct the (false positive) error of your
> specification by failing to include (3).
>
> You may use the above three criteria in your spec only if you post my
> copyright notice: Copyright 2022 PL Olcott
>
> After you fully copycat my criteria your pathological reference
> detector might be valid. You may not copycat this criteria without my
> copyright notice.
>
> *Halting problem proofs refuted on the basis of software engineering*
> https://www.researchgate.net/publication/361701808_Halting_problem_proofs_refuted_on_the_basis_of_software_engineering

Click here to read the complete article

Re: Halting problem proofs refuted on the basis of software engineering [ establishing my authorship and asserting my copyrights ]

<zOmAK.59871$%e2.10898@fx40.iad>

  copy mid

https://www.novabbs.com/devel/article-flat.php?id=35709&group=comp.theory#35709

  copy link   Newsgroups: comp.lang.c comp.lang.c++ comp.theory sci.logic
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx40.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.11.0
Subject: Re: Halting problem proofs refuted on the basis of software
engineering [ establishing my authorship and asserting my copyrights ]
Content-Language: en-US
Newsgroups: comp.lang.c,comp.lang.c++,comp.theory,sci.logic
References: <FcSdnWH56LrW8U3_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715130620.0000483f@reddwarf.jmc.corp>
<esudnY0OB8EN6kz_nZ2dnUU7_81j4p2d@giganews.com>
<20220715153211.00005430@reddwarf.jmc.corp>
<JeidnSoS1rskH0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715164900.00006bca@reddwarf.jmc.corp>
<N7ednc5HcpwLE0z_nZ2dnUU7_81j4p2d@giganews.com>
<20220715170340.00001838@reddwarf.jmc.corp>
<aZudnWdIoajRAEz_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715180822.000061f6@reddwarf.jmc.corp>
<20220715182802.0000170e@reddwarf.jmc.corp>
<2KidnQBTRtnJO0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715184619.00003607@reddwarf.jmc.corp>
<KbSdncHSDus_N0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715190440.00001376@reddwarf.jmc.corp>
<qLGdnfQQtoHfMkz_nZ2dnUU7_83NnZ2d@giganews.com>
<XqqdnZWta5oKL0z_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220715194148.00005b14@reddwarf.jmc.corp>
<y6qdnTUA2dGqJ0z_nZ2dnUU7_83NnZ2d@giganews.com>
<20220715201115.000077ac@reddwarf.jmc.corp>
<ppidncG2cMtZIkz_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <ppidncG2cMtZIkz_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 54
Message-ID: <zOmAK.59871$%e2.10898@fx40.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 15 Jul 2022 19:32:47 -0400
X-Received-Bytes: 4195
 by: Richard Damon - Fri, 15 Jul 2022 23:32 UTC

On 7/15/22 3:28 PM, olcott wrote:
>
> *I have a copyright on these words and every precise paraphrase*

IMPOSSIBLE, you can only copyright what you write.

You can possible show that a paraphrase violates you artistic expression
of your statement, but you can't actually copyright an "idea"
>
> When simulating halt decider H(P,P) simulates its input we can see that:
> (1) Function H() is called from P().
> (2) With the same arguments to H().
> (3) With no instructions in P preceding its invocation of H(P,P).
>

And since (3) is INCORRECT (as far as actual halting, and the way you
use it) you whole proof is show to be incorrect.

The ACTUAL rule similar to that includes the code in H that P calls.

> https://en.wikipedia.org/wiki/Paraphrasing_of_copyrighted_material

So, you didn't read what it said?

> United States copyright law protects original expressions but not facts, methods, discoveries, or other ideas being expressed, a doctrine known as the idea–expression distinction. Despite making this distinction, verbatim copying is not always required for copyright infringement, as paraphrasing is also prohibited in certain circumstances.

so, unless you are actually ADMITTING that you statement isn't a "Fact"
or a "Discovery", you can't actully claim copyright on what you have said.

Which, I suppose IS what you are doing, (Admitting it that is).

>
> You are expressing using (1)
> "When the simulator detects the call to H in P"
> https://github.com/i42output/halting-problem/blob/main/README.txt
>
> have referred to (2) after the fact when I pointed out that it was
> missing from your spec
>
> On 7/15/2022 1:41 PM, Mr Flibble wrote:
> > ... if H is called with the same input more than once.
>
> and have not bothered to correct the (false positive) error of your
> specification by failing to include (3).
>
> You may use the above three criteria in your spec only if you post my
> copyright notice: Copyright 2022 PL Olcott
>
> After you fully copycat my criteria your pathological reference detector
> might be valid. You may not copycat this criteria without my copyright
> notice.
>
> *Halting problem proofs refuted on the basis of software engineering*

1
server_pubkey.txt

rocksolid light 0.9.8
clearnet tor