Only an ordinary understanding of C and software engineering is required.

#define ptr uintptr_t

int H(ptr p, ptr i); // simulating halt decider

H Simulates its input until it correctly predicts that this simulated
input would never terminate normally then rejects this input as non-halting.

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

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

When the execution trace of function P() simulated by function H() shows:
(1) Function H() is called from P().
(2) With the same parameters to H().
(3) With no instructions in P() that could escape this infinitely
recursive simulation: {index jump, conditional branch, return}

Then the function call from P() to H() would never terminate normally.
In this case H aborts its simulation of P and rejects its input as
non-halting.

--
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 Monday, July 11, 2022 at 7:58:52 AM UTC-7, olcott wrote:
> Only an ordinary understanding of C and software engineering is required.
>
> int H(ptr p, ptr i); // simulating halt decider
>
> H Simulates its input until it correctly predicts that this simulated
> input would never terminate normally then rejects this input as non-halting.
>
Which is not the classical Turning Machine question.

On 7/11/2022 2:25 PM, dklei...@gmail.com wrote:
> On Monday, July 11, 2022 at 7:58:52 AM UTC-7, olcott wrote:
>> Only an ordinary understanding of C and software engineering is required.
>>
>> int H(ptr p, ptr i); // simulating halt decider
>>
>> H Simulates its input until it correctly predicts that this simulated
>> input would never terminate normally then rejects this input as non-halting.
>>
> Which is not the classical Turning Machine question.

*Once this is accepted*
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 this is understood to implement that (by logical necessity)*
Every simulating halt decider that correctly simulates its input until
it correctly predicts that this simulated input would never reach its
final state, correctly rejects this input as non-halting.

--
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/11/2022 2:25 PM, dklei...@gmail.com wrote:
> On Monday, July 11, 2022 at 7:58:52 AM UTC-7, olcott wrote:
>> Only an ordinary understanding of C and software engineering is required.
>>
>> int H(ptr p, ptr i); // simulating halt decider
>>
>> H Simulates its input until it correctly predicts that this simulated
>> input would never terminate normally then rejects this input as non-halting.
>>
> Which is not the classical Turning Machine question.

*Once this halt deciding principle is accepted*
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 is understood to implement that*
Every simulating halt decider that correctly simulates its input until
it correctly predicts that this simulated input would never reach its
final state, correctly rejects this input as non-halting.

*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/11/22 10:58 AM, olcott wrote:
> Only an ordinary understanding of C and software engineering is required.
>
> #define ptr uintptr_t
>
> int H(ptr p, ptr i); // simulating halt decider
>
> H Simulates its input until it correctly predicts that this simulated
> input would never terminate normally then rejects this input as
> non-halting.
>
> void P(ptr x)
>  {
>   if (H(x, x))
>     HERE: goto HERE;
>   return;
>  }
>
> int main()
>  {
>   Output("Input_Halts = ", H(P, P));
>  }
>
> When the execution trace of function P() simulated by function H() shows:
> (1) Function H() is called from P().
> (2) With the same parameters to H().
> (3) With no instructions in P() that could escape this infinitely
> recursive simulation: {index jump, conditional branch, return}
>
> Then the function call from P() to H() would never terminate normally.
> In this case H aborts its simulation of P and rejects its input as
> non-halting.
>

Which doesn't actually prove anything.

Your (3) is incorrect, since there ARE instruction in the "loop", namely
in H that can, and do if H(P,P) answers, break the loop, and those
instruction are part of the PROGRAM P.

You are just showing your ignorance to the basics.

On 7/11/22 3:35 PM, olcott wrote:
> On 7/11/2022 2:25 PM, dklei...@gmail.com wrote:
>> On Monday, July 11, 2022 at 7:58:52 AM UTC-7, olcott wrote:
>>> Only an ordinary understanding of C and software engineering is
>>> required.
>>>
>>> int H(ptr p, ptr i); // simulating halt decider
>>>
>>> H Simulates its input until it correctly predicts that this simulated
>>> input would never terminate normally then rejects this input as
>>> non-halting.
>>>
>> Which is not the classical Turning Machine question.
>
>
> *Once this is accepted*
> 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.

Right, but the "Actual Behavior" of that input is the behavior of the
program that input represents with the input also specified.

Thus the behavior of the input to H(P,P) is the behavior of P(P).

If it isn't then you haven't defined your P correctly.

>
> *Then this is understood to implement that (by logical necessity)*
> Every simulating halt decider that correctly simulates its input until
> it correctly predicts that this simulated input would never reach its
> final state, correctly rejects this input as non-halting.
>

*IF* it does the decision CORRECTLY, which means, if the program in the
input use a copy of the decider, that copy must behave the same as the
actual decider, since deciders are required to be actual comptations, so
always return the same answer for the same input.

Thus if H(P,P) returns 0 when directly asked, then H needs to take into
account that if P calls H(P,P) that this call will also return a 0.