// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{ u32 Input_Halts = H(x, x);
if (Input_Halts)
HERE: goto HERE;
}

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

When the simulation of the Turing machine description ⟨P⟩ of a Turing
machine P on input I never halts we know that P(I) never halts.

Simulating halt deciders must abort their simulation of all inputs where
the pure simulation of this input would never halt.

Simulating halt deciders act as a pure simulators of their input until
this input demonstrates non-halting behavior.

This allows simulating halt deciders to totally ignore their own
behavior in making their halt status decision.

It is this feature of the adapted halt deciding criteria that eliminates
the pathological self-reference (Olcott 2004) from the halting problem
counter-example templates.

Simulating halt deciders never have behavior that effects their halt
status decision because they only act as pure simulators until after
they have made this decision.

Using the above reasoning we can know that when the execution trace of P
on input P shows that there is no code in P that escapes the infinitely
nested simulation of P on input P, then we know that P on input P meets
the definition of a computation that never halts: (a pure simulation
that never halts).

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 7/6/21 8:43 PM, olcott wrote:
> // Simplified Linz Ĥ (Linz:1990:319)
> void P(u32 x)
> {
>   u32 Input_Halts = H(x, x);
>   if (Input_Halts)
>     HERE: goto HERE;
> }
>
> int main()
> {
>   u32 Input_Halts = H((u32)P, (u32)P);
>   Output("Input_Halts = ", Input_Halts);
> }
>
> When the simulation of the Turing machine description ⟨P⟩ of a Turing
> machine P on input I never halts we know that P(I) never halts.
>
> Simulating halt deciders must abort their simulation of all inputs where
> the pure simulation of this input would never halt.
>
> Simulating halt deciders act as a pure simulators of their input until
> this input demonstrates non-halting behavior.

But since the CAN abort their input, you MUST take that into account if
they run into another decider in their simulation.

>
> This allows simulating halt deciders to totally ignore their own
> behavior in making their halt status decision.

No, it doesn't.

Do you have ANY actual PROOF of this statement (you know, a formal
argument for accepted truths and principles?), or even a respect
authority making this claim?

With out this, the statement is just rubbish.

>
> It is this feature of the adapted halt deciding criteria that eliminates
> the pathological self-reference (Olcott 2004) from the halting problem
> counter-example templates.

Except it doesn't

> Simulating halt deciders never have behavior that effects their halt
> status decision because they only act as pure simulators until after
> they have made this decision.

Until the meet another decider like them, then that decider WILL affect
the machine they are deciding on.

>
> Using the above reasoning we can know that when the execution trace of P
> on input P shows that there is no code in P that escapes the infinitely
> nested simulation of P on input P, then we know that P on input P meets
> the definition of a computation that never halts: (a pure simulation
> that never halts).
>

Yea, you get nice wrong answer with that.
>
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
>

On 7/6/2021 9:23 PM, Richard Damon wrote:
> On 7/6/21 8:43 PM, olcott wrote:
>> // Simplified Linz Ĥ (Linz:1990:319)
>> void P(u32 x)
>> {
>>   u32 Input_Halts = H(x, x);
>>   if (Input_Halts)
>>     HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>   u32 Input_Halts = H((u32)P, (u32)P);
>>   Output("Input_Halts = ", Input_Halts);
>> }
>>
>> When the simulation of the Turing machine description ⟨P⟩ of a Turing
>> machine P on input I never halts we know that P(I) never halts.
>>
>> Simulating halt deciders must abort their simulation of all inputs where
>> the pure simulation of this input would never halt.
>>
>> Simulating halt deciders act as a pure simulators of their input until
>> this input demonstrates non-halting behavior.
>
> But since the CAN abort their input, you MUST take that into account if
> they run into another decider in their simulation.
>
>>
>> This allows simulating halt deciders to totally ignore their own
>> behavior in making their halt status decision.
>
> No, it doesn't.
>
> Do you have ANY actual PROOF of this statement (you know, a formal
> argument for accepted truths and principles?), or even a respect
> authority making this claim?
>
> With out this, the statement is just rubbish.

The simulation of the Turing machine description of a Turing machine P
on input I is computationally equivalent to the execution of P on I.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

On 7/6/21 11:16 PM, olcott wrote:
> On 7/6/2021 9:23 PM, Richard Damon wrote:
>> On 7/6/21 8:43 PM, olcott wrote:
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> void P(u32 x)
>>> {
>>>    u32 Input_Halts = H(x, x);
>>>    if (Input_Halts)
>>>      HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>    u32 Input_Halts = H((u32)P, (u32)P);
>>>    Output("Input_Halts = ", Input_Halts);
>>> }
>>>
>>> When the simulation of the Turing machine description ⟨P⟩ of a Turing
>>> machine P on input I never halts we know that P(I) never halts.
>>>
>>> Simulating halt deciders must abort their simulation of all inputs where
>>> the pure simulation of this input would never halt.
>>>
>>> Simulating halt deciders act as a pure simulators of their input until
>>> this input demonstrates non-halting behavior.
>>
>> But since the CAN abort their input, you MUST take that into account if
>> they run into another decider in their simulation.
>>
>>>
>>> This allows simulating halt deciders to totally ignore their own
>>> behavior in making their halt status decision.
>>
>> No, it doesn't.
>>
>> Do you have ANY actual PROOF of this statement (you know, a formal
>> argument for accepted truths and principles?), or even a respect
>> authority making this claim?
>>
>> With out this, the statement is just rubbish.
>
> The simulation of the Turing machine description of a Turing machine P
> on input I is computationally equivalent to the execution of P on I.
>

Right, but that still doesn't give any evidence that H gets to ignore
copies of itself that are part of P.

H needs to answer about what *P* does, ALL of P, not part of it.

The H that P 'calls' IS PART OF P. PERIOD.

Try to PROVE otherwise.

On 7/6/21 11:16 PM, olcott wrote:
> On 7/6/2021 9:23 PM, Richard Damon wrote:
>> On 7/6/21 8:43 PM, olcott wrote:
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> void P(u32 x)
>>> {
>>>    u32 Input_Halts = H(x, x);
>>>    if (Input_Halts)
>>>      HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>    u32 Input_Halts = H((u32)P, (u32)P);
>>>    Output("Input_Halts = ", Input_Halts);
>>> }
>>>
>>> When the simulation of the Turing machine description ⟨P⟩ of a Turing
>>> machine P on input I never halts we know that P(I) never halts.
>>>
>>> Simulating halt deciders must abort their simulation of all inputs where
>>> the pure simulation of this input would never halt.
>>>
>>> Simulating halt deciders act as a pure simulators of their input until
>>> this input demonstrates non-halting behavior.
>>
>> But since the CAN abort their input, you MUST take that into account if
>> they run into another decider in their simulation.
>>
>>>
>>> This allows simulating halt deciders to totally ignore their own
>>> behavior in making their halt status decision.
>>
>> No, it doesn't.
>>
>> Do you have ANY actual PROOF of this statement (you know, a formal
>> argument for accepted truths and principles?), or even a respect
>> authority making this claim?
>>
>> With out this, the statement is just rubbish.
>
> The simulation of the Turing machine description of a Turing machine P
> on input I is computationally equivalent to the execution of P on I.
>

Also, this ONLY holds if you actually unconditionally simulate, and not
abort the simulation. If H can abort a simulation, then you CAN't just
replace the simulation by the simulated code.

my main result is that monotone reason is linearly decidable.
i have worked out the monotone program details in bob
a one thousand line c++ program. in the following
essentially i deleted "we know" from pooh by petey oh to get:

When the simulation of the Turing machine description ⟨P⟩ of a Turing
machine P on input I never halts P(I) never halts.

Simulating halt deciders must abort their simulation of all inputs where
the pure simulation of this input never halt.

Simulating halt deciders act as a pure simulators of their input
this input demonstrates non-halting behavior.

This allows simulating halt deciders to totally ignore their own
behavior in making their halt status decision.

It is this feature of the adapted halt deciding criteria that eliminates
the pathological self-reference (Olcott 2004) from the halting problem
counter-example templates.

Simulating halt deciders never have behavior that effects their halt
status decision because they only act as pure simulators until after
they have made this decision.

Using the above reasoning when the execution trace of P
on input P shows that there is no code in P that escapes the infinitely
nested simulation of P on input P, then P on input P meets
the definition of a computation that never halts: (a pure simulation
that never halts).