On 7/15/2022 2:14 PM, Skep Dick wrote:
> Pete,
>
> We have gone over this stuff on PhilosophyNow a million times ( https://bit.ly/3APqNIt ).
> I am telling you what these poor people are telling you.
>
> Why are wasting everyone's time?!?
>
> On Thursday, 14 July 2022 at 21:20:00 UTC+2, 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));
>> }
>
> Your code doesn't even compile!
>
> If you just want to argue - then argue with your compiler/linker. Leave the poor souls alone!
>

That I have not yet released my proprietary code is no indication
what-so-ever that this code does not exist. The halt decider code has
been finally transformed into a computable function and cleaned up so
that it could be released at any time. The 50 pages of the x86utm
operating system need much refactoring code clean up.

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.
H(P,P) simulates its input then P calls H(P,P) to simulate itself again.

Because H sees the same (1)(2)(3) that we see H can see that this
otherwise infinitely nested simulation would never end. H aborts its
simulation of P and rejects P as non-halting.

Competent software engineers can verify that the above is correct if
they can get over their strongly held false assumption that I must be
incorrect and actually carefully study the above analysis.

That this can be easily validated is indicated by thousands of reviews
that found no mistake in the claim that H does correctly determine that
the actual behavior of its actual input is correctly rejected as
non-halting.

The only "rebuttal" left is that some people believe that the halting
theorem requires H to determine the halt status of a sequence of
instructions that is not the actual behavior of the actual input.

People just can't believe that when H correctly simulates its input this
simulated input has different behavior than the direct execution of P(P)
even though this difference in behavior is an easily verified fact.

*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 7/15/2022 3:01 PM, Skep Dick wrote:
> On Friday, 15 July 2022 at 21:49:13 UTC+2, olcott wrote:
>> That I have not yet released my proprietary code is no indication
>> what-so-ever that this code does not exist.
>
> Yeah. It is. From P's perspective H doesn't exist.
> From the compiler's perspective H doesn't exist.
>
> Obviously - it's undefined.
>
>> The halt decider code has
>> been finally transformed into a computable function and cleaned up so
>> that it could be released at any time. The 50 pages of the x86utm
>> operating system need much refactoring code clean up.
>
> Great! When you release the source code, I will happily do the following...
>
> P launches a virtual machine (QEMU, VMware, EC2 - doesn't matter).
> This virtual machine will run your x86utm operating system and will contain your halting decider H.
> I will proceed to execute the halting decider
>
> If QEMU running x86utm running H running P decides that P halts then P goes into infinite loop.
> If QEMU running x86utm running H running P decides that P doesn't halt then P halts.
>

The DebugStep(*master_state, *slave_state, *decoded);
function of my x86utm operating system already embeds a world class x86
emulator to provide its core functionality.

Because the correctly emulated P calls H(P,P) in what is essentially
infinite recursion this correctly emulated P never reaches the point in
its execution trace where it can possibly do the opposite of whatever
H(P,P) returns.

It is quite common knowledge among software engineers that functions
called in infinite recursion never return to their caller.

--
Copyright 2022 Pete Olcott

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