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

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>...
> 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));
> }

Try this main(), tell us the result.

int main()
{ Output("Input_Halts = ", H(P, P));
P(P);
}

On 7/14/2022 2:36 PM, wij wrote:
> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>> ...
>> 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));
>> }
>
> Try this main(), tell us the result.
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> P(P);
> }

Been there done that many times.

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.

It is common knowledge that a correct simulation of a program is a
correct measure of the behavior of this program.

If we accept that the behavior of the executed P(P) is the behavior that
H must report on then we are saying that H must report on the behavior
that is not the actual behavior of its actual input.

*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

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
> On 7/14/2022 2:36 PM, wij wrote:
> > On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
> >> ...
> >> 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));
> >> }
> >
> > Try this main(), tell us the result.
> >
> > int main()
> > {
> > Output("Input_Halts = ", H(P, P));
> > P(P);
> > }
> Been there done that many times.
> 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.
> It is common knowledge that a correct simulation of a program is a
> correct measure of the behavior of this program.
>
> If we accept that the behavior of the executed P(P) is the behavior that
> H must report on then we are saying that H must report on the behavior
> that is not the actual behavior of its actual input.
> *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
>
>
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

Are you so impotent and don't know the result of this simple main()?

On 7/14/2022 3:16 PM, wij wrote:
> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>> On 7/14/2022 2:36 PM, wij wrote:
>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>> ...
>>>> 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));
>>>> }
>>>
>>> Try this main(), tell us the result.
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H(P, P));
>>> P(P);
>>> }
>> Been there done that many times.
>> 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.
>> It is common knowledge that a correct simulation of a program is a
>> correct measure of the behavior of this program.
>>
>> If we accept that the behavior of the executed P(P) is the behavior that
>> H must report on then we are saying that H must report on the behavior
>> that is not the actual behavior of its actual input.
>> *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
>>
>>
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> Are you so impotent and don't know the result of this simple main()?

I know the result and posted the result and all of the code and full
execution trace dozens of times. I am skipping ahead and saying why
these results don't matter.

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.

P(P) is not the actual behavior of the actual inputs.
P(P) is not the actual behavior of the actual inputs.
P(P) is not the actual behavior of the actual inputs.
P(P) is not the actual behavior of the actual inputs.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
> On 7/14/2022 3:16 PM, wij wrote:
> > On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
> >> On 7/14/2022 2:36 PM, wij wrote:
> >>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
> >>>> ...
> >>>> 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));
> >>>> }
> >>>
> >>> Try this main(), tell us the result.
> >>>
> >>> int main()
> >>> {
> >>> Output("Input_Halts = ", H(P, P));
> >>> P(P);
> >>> }
> >> Been there done that many times.
> >> 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.
> >> It is common knowledge that a correct simulation of a program is a
> >> correct measure of the behavior of this program.
> >>
> >> If we accept that the behavior of the executed P(P) is the behavior that
> >> H must report on then we are saying that H must report on the behavior
> >> that is not the actual behavior of its actual input.
> >> *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
> >>
> >>
> >> --
> >> Copyright 2022 Pete Olcott
> >>
> >> "Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see."
> >> Arthur Schopenhauer
> >
> > Are you so impotent and don't know the result of this simple main()?
> I know the result and posted the result and all of the code and full
> execution trace dozens of times. I am skipping ahead and saying why
> these results don't matter.
> 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.
> P(P) is not the actual behavior of the actual inputs.
> P(P) is not the actual behavior of the actual inputs.
> P(P) is not the actual behavior of the actual inputs.
> P(P) is not the actual behavior of the actual inputs.
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

I did not say anything, simple asking what the result of this main() is to establish
basic fact of discussion.

int main()
{ Output("Input_Halts = ", H(P, P));
P(P);
}

On 7/14/2022 3:27 PM, wij wrote:
> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
>> On 7/14/2022 3:16 PM, wij wrote:
>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>>> On 7/14/2022 2:36 PM, wij wrote:
>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>>> ...
>>>>>> 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));
>>>>>> }
>>>>>
>>>>> Try this main(), tell us the result.
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(P, P));
>>>>> P(P);
>>>>> }
>>>> Been there done that many times.
>>>> 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.
>>>> It is common knowledge that a correct simulation of a program is a
>>>> correct measure of the behavior of this program.
>>>>
>>>> If we accept that the behavior of the executed P(P) is the behavior that
>>>> H must report on then we are saying that H must report on the behavior
>>>> that is not the actual behavior of its actual input.
>>>> *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
>>>>
>>>>
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> Are you so impotent and don't know the result of this simple main()?
>> I know the result and posted the result and all of the code and full
>> execution trace dozens of times. I am skipping ahead and saying why
>> these results don't matter.
>> 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.
>> P(P) is not the actual behavior of the actual inputs.
>> P(P) is not the actual behavior of the actual inputs.
>> P(P) is not the actual behavior of the actual inputs.
>> P(P) is not the actual behavior of the actual inputs.
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> I did not say anything, simple asking what the result of this main() is to establish
> basic fact of discussion.
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> P(P);
> }

void P(ptr x)
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return;
}

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.

P(P) is not the actual behavior of the actual inputs to H(P,P)
P(P) is not the actual behavior of the actual inputs to H(P,P)
P(P) is not the actual behavior of the actual inputs to H(P,P)
P(P) is not the actual behavior of the actual inputs to H(P,P)

If you have enough technical skill you can find the answer to your
question in the code below.

int main()
{ P(P);
}

_P()
[000013b4](01) 55 push ebp
[000013b5](02) 8bec mov ebp,esp
[000013b7](01) 51 push ecx
[000013b8](03) 8b4508 mov eax,[ebp+08]
[000013bb](01) 50 push eax
[000013bc](03) 8b4d08 mov ecx,[ebp+08]
[000013bf](01) 51 push ecx
[000013c0](05) e82ffdffff call 000010f4
[000013c5](03) 83c408 add esp,+08
[000013c8](03) 8945fc mov [ebp-04],eax
[000013cb](04) 837dfc00 cmp dword [ebp-04],+00
[000013cf](02) 7402 jz 000013d3
[000013d1](02) ebfe jmp 000013d1
[000013d3](02) 8be5 mov esp,ebp
[000013d5](01) 5d pop ebp
[000013d6](01) c3 ret
Size in bytes:(0035) [000013d6]

_main()
[000013e4](01) 55 push ebp
[000013e5](02) 8bec mov ebp,esp
[000013e7](05) 68b4130000 push 000013b4
[000013ec](05) e8c3ffffff call 000013b4
[000013f1](03) 83c404 add esp,+04
[000013f4](02) 33c0 xor eax,eax
[000013f6](01) 5d pop ebp
[000013f7](01) c3 ret
Size in bytes:(0020) [000013f7]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[000013e4][0010230a][00000000] 55 push ebp
[000013e5][0010230a][00000000] 8bec mov ebp,esp
[000013e7][00102306][000013b4] 68b4130000 push 000013b4
[000013ec][00102302][000013f1] e8c3ffffff call 000013b4
[000013b4][001022fe][0010230a] 55 push ebp
[000013b5][001022fe][0010230a] 8bec mov ebp,esp
[000013b7][001022fa][00000000] 51 push ecx
[000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
[000013bb][001022f6][000013b4] 50 push eax
[000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
[000013bf][001022f2][000013b4] 51 push ecx
[000013c0][001022ee][000013c5] e82ffdffff call 000010f4

H: Begin Simulation Execution Trace Stored at:1123b6
Address_of_H:10f4
[000013b4][001123a2][001123a6] 55 push ebp
[000013b5][001123a2][001123a6] 8bec mov ebp,esp
[000013b7][0011239e][00102372] 51 push ecx
[000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
[000013bb][0011239a][000013b4] 50 push eax
[000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
[000013bf][00112396][000013b4] 51 push ecx
[000013c0][00112392][000013c5] e82ffdffff call 000010f4
H: Infinitely Recursive Simulation Detected Simulation Stopped

[000013c5][001022fa][00000000] 83c408 add esp,+08
[000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
[000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
[000013cf][001022fa][00000000] 7402 jz 000013d3
[000013d3][001022fe][0010230a] 8be5 mov esp,ebp
[000013d5][00102302][000013f1] 5d pop ebp
[000013d6][00102306][000013b4] c3 ret
[000013f1][0010230a][00000000] 83c404 add esp,+04
[000013f4][0010230a][00000000] 33c0 xor eax,eax
[000013f6][0010230e][00000018] 5d pop ebp
[000013f7][00102312][00000000] c3 ret
Number of Instructions Executed(998) == 15 Pages

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

On Friday, 15 July 2022 at 05:21:18 UTC+8, olcott wrote:
> On 7/14/2022 3:27 PM, wij wrote:
> > On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
> >> On 7/14/2022 3:16 PM, wij wrote:
> >>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
> >>>> On 7/14/2022 2:36 PM, wij wrote:
> >>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
> >>>>>> ...
> >>>>>> 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));
> >>>>>> }
> >>>>>
> >>>>> Try this main(), tell us the result.
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> Output("Input_Halts = ", H(P, P));
> >>>>> P(P);
> >>>>> }
> >>>> Been there done that many times.
> >>>> 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.
> >>>> It is common knowledge that a correct simulation of a program is a
> >>>> correct measure of the behavior of this program.
> >>>>
> >>>> If we accept that the behavior of the executed P(P) is the behavior that
> >>>> H must report on then we are saying that H must report on the behavior
> >>>> that is not the actual behavior of its actual input.
> >>>> *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
> >>>>
> >>>>
> >>>> --
> >>>> Copyright 2022 Pete Olcott
> >>>>
> >>>> "Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see."
> >>>> Arthur Schopenhauer
> >>>
> >>> Are you so impotent and don't know the result of this simple main()?
> >> I know the result and posted the result and all of the code and full
> >> execution trace dozens of times. I am skipping ahead and saying why
> >> these results don't matter.
> >> 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.
> >> P(P) is not the actual behavior of the actual inputs.
> >> P(P) is not the actual behavior of the actual inputs.
> >> P(P) is not the actual behavior of the actual inputs.
> >> P(P) is not the actual behavior of the actual inputs.
> >> --
> >> Copyright 2022 Pete Olcott
> >>
> >> "Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see."
> >> Arthur Schopenhauer
> >
> > I did not say anything, simple asking what the result of this main() is to establish
> > basic fact of discussion.
> >
> > int main()
> > {
> > Output("Input_Halts = ", H(P, P));
> > P(P);
> > }
>
>
> void P(ptr x)
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return;
> }
> 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.
> P(P) is not the actual behavior of the actual inputs to H(P,P)
> P(P) is not the actual behavior of the actual inputs to H(P,P)
> P(P) is not the actual behavior of the actual inputs to H(P,P)
> P(P) is not the actual behavior of the actual inputs to H(P,P)
>
> If you have enough technical skill you can find the answer to your
> question in the code below.
>
> int main()
> {
> P(P);
> }
>
> _P()
> [000013b4](01) 55 push ebp
> [000013b5](02) 8bec mov ebp,esp
> [000013b7](01) 51 push ecx
> [000013b8](03) 8b4508 mov eax,[ebp+08]
> [000013bb](01) 50 push eax
> [000013bc](03) 8b4d08 mov ecx,[ebp+08]
> [000013bf](01) 51 push ecx
> [000013c0](05) e82ffdffff call 000010f4
> [000013c5](03) 83c408 add esp,+08
> [000013c8](03) 8945fc mov [ebp-04],eax
> [000013cb](04) 837dfc00 cmp dword [ebp-04],+00
> [000013cf](02) 7402 jz 000013d3
> [000013d1](02) ebfe jmp 000013d1
> [000013d3](02) 8be5 mov esp,ebp
> [000013d5](01) 5d pop ebp
> [000013d6](01) c3 ret
> Size in bytes:(0035) [000013d6]
>
> _main()
> [000013e4](01) 55 push ebp
> [000013e5](02) 8bec mov ebp,esp
> [000013e7](05) 68b4130000 push 000013b4
> [000013ec](05) e8c3ffffff call 000013b4
> [000013f1](03) 83c404 add esp,+04
> [000013f4](02) 33c0 xor eax,eax
> [000013f6](01) 5d pop ebp
> [000013f7](01) c3 ret
> Size in bytes:(0020) [000013f7]
>
> machine stack stack machine assembly
> address address data code language
> ======== ======== ======== ========= =============
> [000013e4][0010230a][00000000] 55 push ebp
> [000013e5][0010230a][00000000] 8bec mov ebp,esp
> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
> [000013b4][001022fe][0010230a] 55 push ebp
> [000013b5][001022fe][0010230a] 8bec mov ebp,esp
> [000013b7][001022fa][00000000] 51 push ecx
> [000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
> [000013bb][001022f6][000013b4] 50 push eax
> [000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
> [000013bf][001022f2][000013b4] 51 push ecx
> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
>
> H: Begin Simulation Execution Trace Stored at:1123b6
> Address_of_H:10f4
> [000013b4][001123a2][001123a6] 55 push ebp
> [000013b5][001123a2][001123a6] 8bec mov ebp,esp
> [000013b7][0011239e][00102372] 51 push ecx
> [000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
> [000013bb][0011239a][000013b4] 50 push eax
> [000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
> [000013bf][00112396][000013b4] 51 push ecx
> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
> H: Infinitely Recursive Simulation Detected Simulation Stopped
>
> [000013c5][001022fa][00000000] 83c408 add esp,+08
> [000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
> [000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
> [000013cf][001022fa][00000000] 7402 jz 000013d3
> [000013d3][001022fe][0010230a] 8be5 mov esp,ebp
> [000013d5][00102302][000013f1] 5d pop ebp
> [000013d6][00102306][000013b4] c3 ret
> [000013f1][0010230a][00000000] 83c404 add esp,+04
> [000013f4][0010230a][00000000] 33c0 xor eax,eax
> [000013f6][0010230e][00000018] 5d pop ebp
> [000013f7][00102312][00000000] c3 ret
> Number of Instructions Executed(998) == 15 Pages
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

Are you really idiot or what? The question ask for the result of this simple main()
What is the output? what is the running status?

int main()
{ Output("Input_Halts = ", H(P, P));
P(P);
}

On 7/14/2022 4:35 PM, wij wrote:
> On Friday, 15 July 2022 at 05:21:18 UTC+8, olcott wrote:
>> On 7/14/2022 3:27 PM, wij wrote:
>>> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
>>>> On 7/14/2022 3:16 PM, wij wrote:
>>>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>>>>> On 7/14/2022 2:36 PM, wij wrote:
>>>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>>>>> ...
>>>>>>>> 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));
>>>>>>>> }
>>>>>>>
>>>>>>> Try this main(), tell us the result.
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>> P(P);
>>>>>>> }
>>>>>> Been there done that many times.
>>>>>> 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.
>>>>>> It is common knowledge that a correct simulation of a program is a
>>>>>> correct measure of the behavior of this program.
>>>>>>
>>>>>> If we accept that the behavior of the executed P(P) is the behavior that
>>>>>> H must report on then we are saying that H must report on the behavior
>>>>>> that is not the actual behavior of its actual input.
>>>>>> *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
>>>>>>
>>>>>>
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> Are you so impotent and don't know the result of this simple main()?
>>>> I know the result and posted the result and all of the code and full
>>>> execution trace dozens of times. I am skipping ahead and saying why
>>>> these results don't matter.
>>>> 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.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> I did not say anything, simple asking what the result of this main() is to establish
>>> basic fact of discussion.
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H(P, P));
>>> P(P);
>>> }
>>
>>
>> void P(ptr x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>> 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.
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>
>> If you have enough technical skill you can find the answer to your
>> question in the code below.
>>
>> int main()
>> {
>> P(P);
>> }
>>
>> _P()
>> [000013b4](01) 55 push ebp
>> [000013b5](02) 8bec mov ebp,esp
>> [000013b7](01) 51 push ecx
>> [000013b8](03) 8b4508 mov eax,[ebp+08]
>> [000013bb](01) 50 push eax
>> [000013bc](03) 8b4d08 mov ecx,[ebp+08]
>> [000013bf](01) 51 push ecx
>> [000013c0](05) e82ffdffff call 000010f4
>> [000013c5](03) 83c408 add esp,+08
>> [000013c8](03) 8945fc mov [ebp-04],eax
>> [000013cb](04) 837dfc00 cmp dword [ebp-04],+00
>> [000013cf](02) 7402 jz 000013d3
>> [000013d1](02) ebfe jmp 000013d1
>> [000013d3](02) 8be5 mov esp,ebp
>> [000013d5](01) 5d pop ebp
>> [000013d6](01) c3 ret
>> Size in bytes:(0035) [000013d6]
>>
>> _main()
>> [000013e4](01) 55 push ebp
>> [000013e5](02) 8bec mov ebp,esp
>> [000013e7](05) 68b4130000 push 000013b4
>> [000013ec](05) e8c3ffffff call 000013b4
>> [000013f1](03) 83c404 add esp,+04
>> [000013f4](02) 33c0 xor eax,eax
>> [000013f6](01) 5d pop ebp
>> [000013f7](01) c3 ret
>> Size in bytes:(0020) [000013f7]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [000013e4][0010230a][00000000] 55 push ebp
>> [000013e5][0010230a][00000000] 8bec mov ebp,esp
>> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
>> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
>> [000013b4][001022fe][0010230a] 55 push ebp
>> [000013b5][001022fe][0010230a] 8bec mov ebp,esp
>> [000013b7][001022fa][00000000] 51 push ecx
>> [000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
>> [000013bb][001022f6][000013b4] 50 push eax
>> [000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
>> [000013bf][001022f2][000013b4] 51 push ecx
>> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
>>
>> H: Begin Simulation Execution Trace Stored at:1123b6
>> Address_of_H:10f4
>> [000013b4][001123a2][001123a6] 55 push ebp
>> [000013b5][001123a2][001123a6] 8bec mov ebp,esp
>> [000013b7][0011239e][00102372] 51 push ecx
>> [000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
>> [000013bb][0011239a][000013b4] 50 push eax
>> [000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
>> [000013bf][00112396][000013b4] 51 push ecx
>> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> [000013c5][001022fa][00000000] 83c408 add esp,+08
>> [000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
>> [000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
>> [000013cf][001022fa][00000000] 7402 jz 000013d3
>> [000013d3][001022fe][0010230a] 8be5 mov esp,ebp
>> [000013d5][00102302][000013f1] 5d pop ebp
>> [000013d6][00102306][000013b4] c3 ret
>> [000013f1][0010230a][00000000] 83c404 add esp,+04
>> [000013f4][0010230a][00000000] 33c0 xor eax,eax
>> [000013f6][0010230e][00000018] 5d pop ebp
>> [000013f7][00102312][00000000] c3 ret
>> Number of Instructions Executed(998) == 15 Pages
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> Are you really idiot or what? The question ask for the result of this simple main()
> What is the output? what is the running status?
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> P(P);
> }

On Friday, 15 July 2022 at 05:41:48 UTC+8, olcott wrote:
> On 7/14/2022 4:35 PM, wij wrote:
> > On Friday, 15 July 2022 at 05:21:18 UTC+8, olcott wrote:
> >> On 7/14/2022 3:27 PM, wij wrote:
> >>> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
> >>>> On 7/14/2022 3:16 PM, wij wrote:
> >>>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
> >>>>>> On 7/14/2022 2:36 PM, wij wrote:
> >>>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
> >>>>>>>> ...
> >>>>>>>> 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));
> >>>>>>>> }
> >>>>>>>
> >>>>>>> Try this main(), tell us the result.
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H(P, P));
> >>>>>>> P(P);
> >>>>>>> }
> >>>>>> Been there done that many times.
> >>>>>> 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.
> >>>>>> It is common knowledge that a correct simulation of a program is a
> >>>>>> correct measure of the behavior of this program.
> >>>>>>
> >>>>>> If we accept that the behavior of the executed P(P) is the behavior that
> >>>>>> H must report on then we are saying that H must report on the behavior
> >>>>>> that is not the actual behavior of its actual input.
> >>>>>> *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
> >>>>>>
> >>>>>>
> >>>>>> --
> >>>>>> Copyright 2022 Pete Olcott
> >>>>>>
> >>>>>> "Talent hits a target no one else can hit;
> >>>>>> Genius hits a target no one else can see."
> >>>>>> Arthur Schopenhauer
> >>>>>
> >>>>> Are you so impotent and don't know the result of this simple main()?
> >>>> I know the result and posted the result and all of the code and full
> >>>> execution trace dozens of times. I am skipping ahead and saying why
> >>>> these results don't matter.
> >>>> 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.
> >>>> P(P) is not the actual behavior of the actual inputs.
> >>>> P(P) is not the actual behavior of the actual inputs.
> >>>> P(P) is not the actual behavior of the actual inputs.
> >>>> P(P) is not the actual behavior of the actual inputs.
> >>>> --
> >>>> Copyright 2022 Pete Olcott
> >>>>
> >>>> "Talent hits a target no one else can hit;
> >>>> Genius hits a target no one else can see."
> >>>> Arthur Schopenhauer
> >>>
> >>> I did not say anything, simple asking what the result of this main() is to establish
> >>> basic fact of discussion.
> >>>
> >>> int main()
> >>> {
> >>> Output("Input_Halts = ", H(P, P));
> >>> P(P);
> >>> }
> >>
> >>
> >> void P(ptr x)
> >> {
> >> int Halt_Status = H(x, x);
> >> if (Halt_Status)
> >> HERE: goto HERE;
> >> return;
> >> }
> >> 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.
> >> P(P) is not the actual behavior of the actual inputs to H(P,P)
> >> P(P) is not the actual behavior of the actual inputs to H(P,P)
> >> P(P) is not the actual behavior of the actual inputs to H(P,P)
> >> P(P) is not the actual behavior of the actual inputs to H(P,P)
> >>
> >> If you have enough technical skill you can find the answer to your
> >> question in the code below.
> >>
> >> int main()
> >> {
> >> P(P);
> >> }
> >>
> >> _P()
> >> [000013b4](01) 55 push ebp
> >> [000013b5](02) 8bec mov ebp,esp
> >> [000013b7](01) 51 push ecx
> >> [000013b8](03) 8b4508 mov eax,[ebp+08]
> >> [000013bb](01) 50 push eax
> >> [000013bc](03) 8b4d08 mov ecx,[ebp+08]
> >> [000013bf](01) 51 push ecx
> >> [000013c0](05) e82ffdffff call 000010f4
> >> [000013c5](03) 83c408 add esp,+08
> >> [000013c8](03) 8945fc mov [ebp-04],eax
> >> [000013cb](04) 837dfc00 cmp dword [ebp-04],+00
> >> [000013cf](02) 7402 jz 000013d3
> >> [000013d1](02) ebfe jmp 000013d1
> >> [000013d3](02) 8be5 mov esp,ebp
> >> [000013d5](01) 5d pop ebp
> >> [000013d6](01) c3 ret
> >> Size in bytes:(0035) [000013d6]
> >>
> >> _main()
> >> [000013e4](01) 55 push ebp
> >> [000013e5](02) 8bec mov ebp,esp
> >> [000013e7](05) 68b4130000 push 000013b4
> >> [000013ec](05) e8c3ffffff call 000013b4
> >> [000013f1](03) 83c404 add esp,+04
> >> [000013f4](02) 33c0 xor eax,eax
> >> [000013f6](01) 5d pop ebp
> >> [000013f7](01) c3 ret
> >> Size in bytes:(0020) [000013f7]
> >>
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> [000013e4][0010230a][00000000] 55 push ebp
> >> [000013e5][0010230a][00000000] 8bec mov ebp,esp
> >> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
> >> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
> >> [000013b4][001022fe][0010230a] 55 push ebp
> >> [000013b5][001022fe][0010230a] 8bec mov ebp,esp
> >> [000013b7][001022fa][00000000] 51 push ecx
> >> [000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
> >> [000013bb][001022f6][000013b4] 50 push eax
> >> [000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
> >> [000013bf][001022f2][000013b4] 51 push ecx
> >> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
> >>
> >> H: Begin Simulation Execution Trace Stored at:1123b6
> >> Address_of_H:10f4
> >> [000013b4][001123a2][001123a6] 55 push ebp
> >> [000013b5][001123a2][001123a6] 8bec mov ebp,esp
> >> [000013b7][0011239e][00102372] 51 push ecx
> >> [000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
> >> [000013bb][0011239a][000013b4] 50 push eax
> >> [000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
> >> [000013bf][00112396][000013b4] 51 push ecx
> >> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
> >> H: Infinitely Recursive Simulation Detected Simulation Stopped
> >>
> >> [000013c5][001022fa][00000000] 83c408 add esp,+08
> >> [000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
> >> [000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
> >> [000013cf][001022fa][00000000] 7402 jz 000013d3
> >> [000013d3][001022fe][0010230a] 8be5 mov esp,ebp
> >> [000013d5][00102302][000013f1] 5d pop ebp
> >> [000013d6][00102306][000013b4] c3 ret
> >> [000013f1][0010230a][00000000] 83c404 add esp,+04
> >> [000013f4][0010230a][00000000] 33c0 xor eax,eax
> >> [000013f6][0010230e][00000018] 5d pop ebp
> >> [000013f7][00102312][00000000] c3 ret
> >> Number of Instructions Executed(998) == 15 Pages
> >> --
> >> Copyright 2022 Pete Olcott
> >>
> >> "Talent hits a target no one else can hit;
> >> Genius hits a target no one else can see."
> >> Arthur Schopenhauer
> >
> > Are you really idiot or what? The question ask for the result of this simple main()
> > What is the output? what is the running status?
> >
> > int main()
> > {
> > Output("Input_Halts = ", H(P, P));
> > P(P);
> > }
> If I don't make you work for the answer you will leap to a false
> assumption about the meaning of this answer and this false assumption
> will reamain stuck in your mind for all future dialogue.
> --
> Copyright 2022 Pete Olcott
>
> "Talent hits a target no one else can hit;
> Genius hits a target no one else can see."
> Arthur Schopenhauer

On 7/14/2022 4:46 PM, wij wrote:
> On Friday, 15 July 2022 at 05:41:48 UTC+8, olcott wrote:
>> On 7/14/2022 4:35 PM, wij wrote:
>>> On Friday, 15 July 2022 at 05:21:18 UTC+8, olcott wrote:
>>>> On 7/14/2022 3:27 PM, wij wrote:
>>>>> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
>>>>>> On 7/14/2022 3:16 PM, wij wrote:
>>>>>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>>>>>>> On 7/14/2022 2:36 PM, wij wrote:
>>>>>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>>>>>>> ...
>>>>>>>>>> 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));
>>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Try this main(), tell us the result.
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>> P(P);
>>>>>>>>> }
>>>>>>>> Been there done that many times.
>>>>>>>> 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.
>>>>>>>> It is common knowledge that a correct simulation of a program is a
>>>>>>>> correct measure of the behavior of this program.
>>>>>>>>
>>>>>>>> If we accept that the behavior of the executed P(P) is the behavior that
>>>>>>>> H must report on then we are saying that H must report on the behavior
>>>>>>>> that is not the actual behavior of its actual input.
>>>>>>>> *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
>>>>>>>>
>>>>>>>>
>>>>>>>> --
>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>
>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>> Genius hits a target no one else can see."
>>>>>>>> Arthur Schopenhauer
>>>>>>>
>>>>>>> Are you so impotent and don't know the result of this simple main()?
>>>>>> I know the result and posted the result and all of the code and full
>>>>>> execution trace dozens of times. I am skipping ahead and saying why
>>>>>> these results don't matter.
>>>>>> 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.
>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> I did not say anything, simple asking what the result of this main() is to establish
>>>>> basic fact of discussion.
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H(P, P));
>>>>> P(P);
>>>>> }
>>>>
>>>>
>>>> void P(ptr x)
>>>> {
>>>> int Halt_Status = H(x, x);
>>>> if (Halt_Status)
>>>> HERE: goto HERE;
>>>> return;
>>>> }
>>>> 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.
>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>>
>>>> If you have enough technical skill you can find the answer to your
>>>> question in the code below.
>>>>
>>>> int main()
>>>> {
>>>> P(P);
>>>> }
>>>>
>>>> _P()
>>>> [000013b4](01) 55 push ebp
>>>> [000013b5](02) 8bec mov ebp,esp
>>>> [000013b7](01) 51 push ecx
>>>> [000013b8](03) 8b4508 mov eax,[ebp+08]
>>>> [000013bb](01) 50 push eax
>>>> [000013bc](03) 8b4d08 mov ecx,[ebp+08]
>>>> [000013bf](01) 51 push ecx
>>>> [000013c0](05) e82ffdffff call 000010f4
>>>> [000013c5](03) 83c408 add esp,+08
>>>> [000013c8](03) 8945fc mov [ebp-04],eax
>>>> [000013cb](04) 837dfc00 cmp dword [ebp-04],+00
>>>> [000013cf](02) 7402 jz 000013d3
>>>> [000013d1](02) ebfe jmp 000013d1
>>>> [000013d3](02) 8be5 mov esp,ebp
>>>> [000013d5](01) 5d pop ebp
>>>> [000013d6](01) c3 ret
>>>> Size in bytes:(0035) [000013d6]
>>>>
>>>> _main()
>>>> [000013e4](01) 55 push ebp
>>>> [000013e5](02) 8bec mov ebp,esp
>>>> [000013e7](05) 68b4130000 push 000013b4
>>>> [000013ec](05) e8c3ffffff call 000013b4
>>>> [000013f1](03) 83c404 add esp,+04
>>>> [000013f4](02) 33c0 xor eax,eax
>>>> [000013f6](01) 5d pop ebp
>>>> [000013f7](01) c3 ret
>>>> Size in bytes:(0020) [000013f7]
>>>>
>>>> machine stack stack machine assembly
>>>> address address data code language
>>>> ======== ======== ======== ========= =============
>>>> [000013e4][0010230a][00000000] 55 push ebp
>>>> [000013e5][0010230a][00000000] 8bec mov ebp,esp
>>>> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
>>>> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
>>>> [000013b4][001022fe][0010230a] 55 push ebp
>>>> [000013b5][001022fe][0010230a] 8bec mov ebp,esp
>>>> [000013b7][001022fa][00000000] 51 push ecx
>>>> [000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
>>>> [000013bb][001022f6][000013b4] 50 push eax
>>>> [000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
>>>> [000013bf][001022f2][000013b4] 51 push ecx
>>>> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
>>>>
>>>> H: Begin Simulation Execution Trace Stored at:1123b6
>>>> Address_of_H:10f4
>>>> [000013b4][001123a2][001123a6] 55 push ebp
>>>> [000013b5][001123a2][001123a6] 8bec mov ebp,esp
>>>> [000013b7][0011239e][00102372] 51 push ecx
>>>> [000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
>>>> [000013bb][0011239a][000013b4] 50 push eax
>>>> [000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
>>>> [000013bf][00112396][000013b4] 51 push ecx
>>>> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>
>>>> [000013c5][001022fa][00000000] 83c408 add esp,+08
>>>> [000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
>>>> [000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
>>>> [000013cf][001022fa][00000000] 7402 jz 000013d3
>>>> [000013d3][001022fe][0010230a] 8be5 mov esp,ebp
>>>> [000013d5][00102302][000013f1] 5d pop ebp
>>>> [000013d6][00102306][000013b4] c3 ret
>>>> [000013f1][0010230a][00000000] 83c404 add esp,+04
>>>> [000013f4][0010230a][00000000] 33c0 xor eax,eax
>>>> [000013f6][0010230e][00000018] 5d pop ebp
>>>> [000013f7][00102312][00000000] c3 ret
>>>> Number of Instructions Executed(998) == 15 Pages
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> Are you really idiot or what? The question ask for the result of this simple main()
>>> What is the output? what is the running status?
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H(P, P));
>>> P(P);
>>> }
>> If I don't make you work for the answer you will leap to a false
>> assumption about the meaning of this answer and this false assumption
>> will reamain stuck in your mind for all future dialogue.
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> The question ask for the result of this simple main()
> What is the output? what is the running status?
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> P(P);
> }

On 7/14/22 3:59 PM, olcott wrote:
> On 7/14/2022 2:36 PM, wij wrote:
>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>> ...
>>> 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));
>>> }
>>
>> Try this main(), tell us the result.
>>
>> int main()
>> {
>>   Output("Input_Halts = ", H(P, P));
>>   P(P);
>> }
>
> Been there done that many times.
>
> 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.
>
> It is common knowledge that a correct simulation of a program is a
> correct measure of the behavior of this program.
>
> If we accept that the behavior of the executed P(P) is the behavior that
> H must report on then we are saying that H must report on the behavior
> that is not the actual behavior of its actual input.

Then P isn't defined correctly. Since P(x) calls H(x,x) then H(x,x) MUST
refer to x(x), even when x = P.

So, all ypou are confirming is that you hae lied.
>
> *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
>
>
>

On 7/14/22 3:22 PM, olcott 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.

So, you are confirming here that when P cals H(P,P) it is asking H about
the computation P(P), as that is the definition?

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

On 7/14/22 4:22 PM, olcott wrote:
> On 7/14/2022 3:16 PM, wij wrote:
>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>> On 7/14/2022 2:36 PM, wij wrote:
>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>> ...
>>>>> 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));
>>>>> }
>>>>
>>>> Try this main(), tell us the result.
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, P));
>>>> P(P);
>>>> }
>>> Been there done that many times.
>>> 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.
>>> It is common knowledge that a correct simulation of a program is a
>>> correct measure of the behavior of this program.
>>>
>>> If we accept that the behavior of the executed P(P) is the behavior that
>>> H must report on then we are saying that H must report on the behavior
>>> that is not the actual behavior of its actual input.
>>> *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
>>>
>>>
>>>
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> Are you so impotent and don't know the result of this simple main()?
>
> I know the result and posted the result and all of the code and full
> execution trace dozens of times. I am skipping ahead and saying why
> these results don't matter.
>
> 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.
>
> P(P) is not the actual behavior of the actual inputs.
> P(P) is not the actual behavior of the actual inputs.
> P(P) is not the actual behavior of the actual inputs.
> P(P) is not the actual behavior of the actual inputs.
>

Then P wasn't written to the specs, so you "proof" is meaningless.

On 7/14/22 5:21 PM, olcott wrote:
> On 7/14/2022 3:27 PM, wij wrote:
>> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
>>> On 7/14/2022 3:16 PM, wij wrote:
>>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>>>> On 7/14/2022 2:36 PM, wij wrote:
>>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>>>> ...
>>>>>>> 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));
>>>>>>> }
>>>>>>
>>>>>> Try this main(), tell us the result.
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>> P(P);
>>>>>> }
>>>>> Been there done that many times.
>>>>> 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.
>>>>> It is common knowledge that a correct simulation of a program is a
>>>>> correct measure of the behavior of this program.
>>>>>
>>>>> If we accept that the behavior of the executed P(P) is the behavior
>>>>> that
>>>>> H must report on then we are saying that H must report on the behavior
>>>>> that is not the actual behavior of its actual input.
>>>>> *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
>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> Copyright 2022 Pete Olcott
>>>>>
>>>>> "Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see."
>>>>> Arthur Schopenhauer
>>>>
>>>> Are you so impotent and don't know the result of this simple main()?
>>> I know the result and posted the result and all of the code and full
>>> execution trace dozens of times. I am skipping ahead and saying why
>>> these results don't matter.
>>> 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.
>>> P(P) is not the actual behavior of the actual inputs.
>>> P(P) is not the actual behavior of the actual inputs.
>>> P(P) is not the actual behavior of the actual inputs.
>>> P(P) is not the actual behavior of the actual inputs.
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> I did not say anything, simple asking what the result of this main()
>> is to establish
>> basic fact of discussion.
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> P(P);
>> }
>
>
> void P(ptr x)
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> 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.
>

No, it doesn't, it only shows that P can not terminate normally if H
fails to be a decider.

Being a "Simulating" decider doesn't releive it of the requrement to
answer in finite time.

> P(P) is not the actual behavior of the actual inputs to H(P,P)
> P(P) is not the actual behavior of the actual inputs to H(P,P)
> P(P) is not the actual behavior of the actual inputs to H(P,P)
> P(P) is not the actual behavior of the actual inputs to H(P,P)

Then P fails to meet its requirements, as P is supposed to ask H about
P(P), and since your P does a H(P,P) if that is the wrong way to ask the
question, you have a fundamental error in P.

>
> If you have enough technical skill you can find the answer to your
> question in the code below.
>
> int main()
> {
>   P(P);
> }
>
> _P()
> [000013b4](01)  55         push ebp
> [000013b5](02)  8bec       mov ebp,esp
> [000013b7](01)  51         push ecx
> [000013b8](03)  8b4508     mov eax,[ebp+08]
> [000013bb](01)  50         push eax
> [000013bc](03)  8b4d08     mov ecx,[ebp+08]
> [000013bf](01)  51         push ecx
> [000013c0](05)  e82ffdffff call 000010f4
> [000013c5](03)  83c408     add esp,+08
> [000013c8](03)  8945fc     mov [ebp-04],eax
> [000013cb](04)  837dfc00   cmp dword [ebp-04],+00
> [000013cf](02)  7402       jz 000013d3
> [000013d1](02)  ebfe       jmp 000013d1
> [000013d3](02)  8be5       mov esp,ebp
> [000013d5](01)  5d         pop ebp
> [000013d6](01)  c3         ret
> Size in bytes:(0035) [000013d6]
>
> _main()
> [000013e4](01)  55         push ebp
> [000013e5](02)  8bec       mov ebp,esp
> [000013e7](05)  68b4130000 push 000013b4
> [000013ec](05)  e8c3ffffff call 000013b4
> [000013f1](03)  83c404     add esp,+04
> [000013f4](02)  33c0       xor eax,eax
> [000013f6](01)  5d         pop ebp
> [000013f7](01)  c3         ret
> Size in bytes:(0020) [000013f7]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [000013e4][0010230a][00000000] 55         push ebp
> [000013e5][0010230a][00000000] 8bec       mov ebp,esp
> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
> [000013b4][001022fe][0010230a] 55         push ebp
> [000013b5][001022fe][0010230a] 8bec       mov ebp,esp
> [000013b7][001022fa][00000000] 51         push ecx
> [000013b8][001022fa][00000000] 8b4508     mov eax,[ebp+08]
> [000013bb][001022f6][000013b4] 50         push eax
> [000013bc][001022f6][000013b4] 8b4d08     mov ecx,[ebp+08]
> [000013bf][001022f2][000013b4] 51         push ecx
> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
>
> H: Begin Simulation   Execution Trace Stored at:1123b6
> Address_of_H:10f4
> [000013b4][001123a2][001123a6] 55         push ebp
> [000013b5][001123a2][001123a6] 8bec       mov ebp,esp
> [000013b7][0011239e][00102372] 51         push ecx
> [000013b8][0011239e][00102372] 8b4508     mov eax,[ebp+08]
> [000013bb][0011239a][000013b4] 50         push eax
> [000013bc][0011239a][000013b4] 8b4d08     mov ecx,[ebp+08]
> [000013bf][00112396][000013b4] 51         push ecx
> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
> H: Infinitely Recursive Simulation Detected Simulation Stopped
>
> [000013c5][001022fa][00000000] 83c408     add esp,+08
> [000013c8][001022fa][00000000] 8945fc     mov [ebp-04],eax
> [000013cb][001022fa][00000000] 837dfc00   cmp dword [ebp-04],+00
> [000013cf][001022fa][00000000] 7402       jz 000013d3
> [000013d3][001022fe][0010230a] 8be5       mov esp,ebp
> [000013d5][00102302][000013f1] 5d         pop ebp
> [000013d6][00102306][000013b4] c3         ret
> [000013f1][0010230a][00000000] 83c404     add esp,+04
> [000013f4][0010230a][00000000] 33c0       xor eax,eax
> [000013f6][0010230e][00000018] 5d         pop ebp
> [000013f7][00102312][00000000] c3         ret
> Number of Instructions Executed(998) == 15 Pages
>
>

On 7/14/22 5:35 PM, wij wrote:
> On Friday, 15 July 2022 at 05:21:18 UTC+8, olcott wrote:
>> On 7/14/2022 3:27 PM, wij wrote:
>>> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
>>>> On 7/14/2022 3:16 PM, wij wrote:
>>>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>>>>> On 7/14/2022 2:36 PM, wij wrote:
>>>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>>>>> ...
>>>>>>>> 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));
>>>>>>>> }
>>>>>>>
>>>>>>> Try this main(), tell us the result.
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>> P(P);
>>>>>>> }
>>>>>> Been there done that many times.
>>>>>> 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.
>>>>>> It is common knowledge that a correct simulation of a program is a
>>>>>> correct measure of the behavior of this program.
>>>>>>
>>>>>> If we accept that the behavior of the executed P(P) is the behavior that
>>>>>> H must report on then we are saying that H must report on the behavior
>>>>>> that is not the actual behavior of its actual input.
>>>>>> *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
>>>>>>
>>>>>>
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> Are you so impotent and don't know the result of this simple main()?
>>>> I know the result and posted the result and all of the code and full
>>>> execution trace dozens of times. I am skipping ahead and saying why
>>>> these results don't matter.
>>>> 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.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> P(P) is not the actual behavior of the actual inputs.
>>>> --
>>>> Copyright 2022 Pete Olcott
>>>>
>>>> "Talent hits a target no one else can hit;
>>>> Genius hits a target no one else can see."
>>>> Arthur Schopenhauer
>>>
>>> I did not say anything, simple asking what the result of this main() is to establish
>>> basic fact of discussion.
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H(P, P));
>>> P(P);
>>> }
>>
>>
>> void P(ptr x)
>> {
>> int Halt_Status = H(x, x);
>> if (Halt_Status)
>> HERE: goto HERE;
>> return;
>> }
>> 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.
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>
>> If you have enough technical skill you can find the answer to your
>> question in the code below.
>>
>> int main()
>> {
>> P(P);
>> }
>>
>> _P()
>> [000013b4](01) 55 push ebp
>> [000013b5](02) 8bec mov ebp,esp
>> [000013b7](01) 51 push ecx
>> [000013b8](03) 8b4508 mov eax,[ebp+08]
>> [000013bb](01) 50 push eax
>> [000013bc](03) 8b4d08 mov ecx,[ebp+08]
>> [000013bf](01) 51 push ecx
>> [000013c0](05) e82ffdffff call 000010f4
>> [000013c5](03) 83c408 add esp,+08
>> [000013c8](03) 8945fc mov [ebp-04],eax
>> [000013cb](04) 837dfc00 cmp dword [ebp-04],+00
>> [000013cf](02) 7402 jz 000013d3
>> [000013d1](02) ebfe jmp 000013d1
>> [000013d3](02) 8be5 mov esp,ebp
>> [000013d5](01) 5d pop ebp
>> [000013d6](01) c3 ret
>> Size in bytes:(0035) [000013d6]
>>
>> _main()
>> [000013e4](01) 55 push ebp
>> [000013e5](02) 8bec mov ebp,esp
>> [000013e7](05) 68b4130000 push 000013b4
>> [000013ec](05) e8c3ffffff call 000013b4
>> [000013f1](03) 83c404 add esp,+04
>> [000013f4](02) 33c0 xor eax,eax
>> [000013f6](01) 5d pop ebp
>> [000013f7](01) c3 ret
>> Size in bytes:(0020) [000013f7]
>>
>> machine stack stack machine assembly
>> address address data code language
>> ======== ======== ======== ========= =============
>> [000013e4][0010230a][00000000] 55 push ebp
>> [000013e5][0010230a][00000000] 8bec mov ebp,esp
>> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
>> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
>> [000013b4][001022fe][0010230a] 55 push ebp
>> [000013b5][001022fe][0010230a] 8bec mov ebp,esp
>> [000013b7][001022fa][00000000] 51 push ecx
>> [000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
>> [000013bb][001022f6][000013b4] 50 push eax
>> [000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
>> [000013bf][001022f2][000013b4] 51 push ecx
>> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
>>
>> H: Begin Simulation Execution Trace Stored at:1123b6
>> Address_of_H:10f4
>> [000013b4][001123a2][001123a6] 55 push ebp
>> [000013b5][001123a2][001123a6] 8bec mov ebp,esp
>> [000013b7][0011239e][00102372] 51 push ecx
>> [000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
>> [000013bb][0011239a][000013b4] 50 push eax
>> [000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
>> [000013bf][00112396][000013b4] 51 push ecx
>> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> [000013c5][001022fa][00000000] 83c408 add esp,+08
>> [000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
>> [000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
>> [000013cf][001022fa][00000000] 7402 jz 000013d3
>> [000013d3][001022fe][0010230a] 8be5 mov esp,ebp
>> [000013d5][00102302][000013f1] 5d pop ebp
>> [000013d6][00102306][000013b4] c3 ret
>> [000013f1][0010230a][00000000] 83c404 add esp,+04
>> [000013f4][0010230a][00000000] 33c0 xor eax,eax
>> [000013f6][0010230e][00000018] 5d pop ebp
>> [000013f7][00102312][00000000] c3 ret
>> Number of Instructions Executed(998) == 15 Pages
>> --
>> Copyright 2022 Pete Olcott
>>
>> "Talent hits a target no one else can hit;
>> Genius hits a target no one else can see."
>> Arthur Schopenhauer
>
> Are you really idiot or what? The question ask for the result of this simple main()
> What is the output? what is the running status?
>
> int main()
> {
> Output("Input_Halts = ", H(P, P));
> P(P);
> }

On 7/14/22 5:49 PM, olcott wrote:
> On 7/14/2022 4:46 PM, wij wrote:
>> On Friday, 15 July 2022 at 05:41:48 UTC+8, olcott wrote:
>>> On 7/14/2022 4:35 PM, wij wrote:
>>>> On Friday, 15 July 2022 at 05:21:18 UTC+8, olcott wrote:
>>>>> On 7/14/2022 3:27 PM, wij wrote:
>>>>>> On Friday, 15 July 2022 at 04:22:49 UTC+8, olcott wrote:
>>>>>>> On 7/14/2022 3:16 PM, wij wrote:
>>>>>>>> On Friday, 15 July 2022 at 03:59:24 UTC+8, olcott wrote:
>>>>>>>>> On 7/14/2022 2:36 PM, wij wrote:
>>>>>>>>>> On Friday, 15 July 2022 at 03:22:17 UTC+8, olcott wrote:
>>>>>>>>>>> ...
>>>>>>>>>>> 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));
>>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Try this main(), tell us the result.
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>> P(P);
>>>>>>>>>> }
>>>>>>>>> Been there done that many times.
>>>>>>>>> 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.
>>>>>>>>> It is common knowledge that a correct simulation of a program is a
>>>>>>>>> correct measure of the behavior of this program.
>>>>>>>>>
>>>>>>>>> If we accept that the behavior of the executed P(P) is the
>>>>>>>>> behavior that
>>>>>>>>> H must report on then we are saying that H must report on the
>>>>>>>>> behavior
>>>>>>>>> that is not the actual behavior of its actual input.
>>>>>>>>> *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
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> --
>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>
>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>> Arthur Schopenhauer
>>>>>>>>
>>>>>>>> Are you so impotent and don't know the result of this simple
>>>>>>>> main()?
>>>>>>> I know the result and posted the result and all of the code and full
>>>>>>> execution trace dozens of times. I am skipping ahead and saying why
>>>>>>> these results don't matter.
>>>>>>> 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.
>>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>>> P(P) is not the actual behavior of the actual inputs.
>>>>>>> --
>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>
>>>>>>> "Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see."
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> I did not say anything, simple asking what the result of this
>>>>>> main() is to establish
>>>>>> basic fact of discussion.
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>> P(P);
>>>>>> }
>>>>>
>>>>>
>>>>> void P(ptr x)
>>>>> {
>>>>> int Halt_Status = H(x, x);
>>>>> if (Halt_Status)
>>>>> HERE: goto HERE;
>>>>> return;
>>>>> }
>>>>> 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.
>>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>>> P(P) is not the actual behavior of the actual inputs to H(P,P)
>>>>>
>>>>> If you have enough technical skill you can find the answer to your
>>>>> question in the code below.
>>>>>
>>>>> int main()
>>>>> {
>>>>> P(P);
>>>>> }
>>>>>
>>>>> _P()
>>>>> [000013b4](01) 55 push ebp
>>>>> [000013b5](02) 8bec mov ebp,esp
>>>>> [000013b7](01) 51 push ecx
>>>>> [000013b8](03) 8b4508 mov eax,[ebp+08]
>>>>> [000013bb](01) 50 push eax
>>>>> [000013bc](03) 8b4d08 mov ecx,[ebp+08]
>>>>> [000013bf](01) 51 push ecx
>>>>> [000013c0](05) e82ffdffff call 000010f4
>>>>> [000013c5](03) 83c408 add esp,+08
>>>>> [000013c8](03) 8945fc mov [ebp-04],eax
>>>>> [000013cb](04) 837dfc00 cmp dword [ebp-04],+00
>>>>> [000013cf](02) 7402 jz 000013d3
>>>>> [000013d1](02) ebfe jmp 000013d1
>>>>> [000013d3](02) 8be5 mov esp,ebp
>>>>> [000013d5](01) 5d pop ebp
>>>>> [000013d6](01) c3 ret
>>>>> Size in bytes:(0035) [000013d6]
>>>>>
>>>>> _main()
>>>>> [000013e4](01) 55 push ebp
>>>>> [000013e5](02) 8bec mov ebp,esp
>>>>> [000013e7](05) 68b4130000 push 000013b4
>>>>> [000013ec](05) e8c3ffffff call 000013b4
>>>>> [000013f1](03) 83c404 add esp,+04
>>>>> [000013f4](02) 33c0 xor eax,eax
>>>>> [000013f6](01) 5d pop ebp
>>>>> [000013f7](01) c3 ret
>>>>> Size in bytes:(0020) [000013f7]
>>>>>
>>>>> machine stack stack machine assembly
>>>>> address address data code language
>>>>> ======== ======== ======== ========= =============
>>>>> [000013e4][0010230a][00000000] 55 push ebp
>>>>> [000013e5][0010230a][00000000] 8bec mov ebp,esp
>>>>> [000013e7][00102306][000013b4] 68b4130000 push 000013b4
>>>>> [000013ec][00102302][000013f1] e8c3ffffff call 000013b4
>>>>> [000013b4][001022fe][0010230a] 55 push ebp
>>>>> [000013b5][001022fe][0010230a] 8bec mov ebp,esp
>>>>> [000013b7][001022fa][00000000] 51 push ecx
>>>>> [000013b8][001022fa][00000000] 8b4508 mov eax,[ebp+08]
>>>>> [000013bb][001022f6][000013b4] 50 push eax
>>>>> [000013bc][001022f6][000013b4] 8b4d08 mov ecx,[ebp+08]
>>>>> [000013bf][001022f2][000013b4] 51 push ecx
>>>>> [000013c0][001022ee][000013c5] e82ffdffff call 000010f4
>>>>>
>>>>> H: Begin Simulation Execution Trace Stored at:1123b6
>>>>> Address_of_H:10f4
>>>>> [000013b4][001123a2][001123a6] 55 push ebp
>>>>> [000013b5][001123a2][001123a6] 8bec mov ebp,esp
>>>>> [000013b7][0011239e][00102372] 51 push ecx
>>>>> [000013b8][0011239e][00102372] 8b4508 mov eax,[ebp+08]
>>>>> [000013bb][0011239a][000013b4] 50 push eax
>>>>> [000013bc][0011239a][000013b4] 8b4d08 mov ecx,[ebp+08]
>>>>> [000013bf][00112396][000013b4] 51 push ecx
>>>>> [000013c0][00112392][000013c5] e82ffdffff call 000010f4
>>>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>
>>>>> [000013c5][001022fa][00000000] 83c408 add esp,+08
>>>>> [000013c8][001022fa][00000000] 8945fc mov [ebp-04],eax
>>>>> [000013cb][001022fa][00000000] 837dfc00 cmp dword [ebp-04],+00
>>>>> [000013cf][001022fa][00000000] 7402 jz 000013d3
>>>>> [000013d3][001022fe][0010230a] 8be5 mov esp,ebp
>>>>> [000013d5][00102302][000013f1] 5d pop ebp
>>>>> [000013d6][00102306][000013b4] c3 ret
>>>>> [000013f1][0010230a][00000000] 83c404 add esp,+04
>>>>> [000013f4][0010230a][00000000] 33c0 xor eax,eax
>>>>> [000013f6][0010230e][00000018] 5d pop ebp
>>>>> [000013f7][00102312][00000000] c3 ret
>>>>> Number of Instructions Executed(998) == 15 Pages
>>>>> --
>>>>> Copyright 2022 Pete Olcott
>>>>>
>>>>> "Talent hits a target no one else can hit;
>>>>> Genius hits a target no one else can see."
>>>>> Arthur Schopenhauer
>>>>
>>>> Are you really idiot or what? The question ask for the result of
>>>> this simple main()
>>>> What is the output? what is the running status?
>>>>
>>>> int main()
>>>> {
>>>> Output("Input_Halts = ", H(P, P));
>>>> P(P);
>>>> }
>>> If I don't make you work for the answer you will leap to a false
>>> assumption about the meaning of this answer and this false assumption
>>> will reamain stuck in your mind for all future dialogue.
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> The question ask for the result of this simple main()
>> What is the output? what is the running status?
>>
>> int main()
>> {
>> Output("Input_Halts = ", H(P, P));
>> P(P);
>> }
>
> That question has been gone over in this forum 10,000 times.
> I have addressed it thousands of times. Enough already.
>