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
You cannot copyright the idea of a simulating halt decider and I have
not copied your words: your approach and my approach are quite
different; my approach works whilst your approach fails to decide the
following correctly:

void Px(void (*x)())
{ (void) H(x, x);
return;
}

Px always halts and my approach returns a correct decision of halting
whilst your approach returns an incorrect decision of non-halting
proving that our approaches are fundamentally different.

/Flibble