int D(int (*x)())
{ int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

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

*This is a key fact that I cannot possibly be gaslighted on* !!!
H correctly determines that D correctly simulated by H cannot possibly
reach its own return statement, then H aborts this simulation and
correctly returns 0 for non-halting.

*Simulating Halt Deciders Defeat the Halting Theorem*
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem

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

On 2/18/23 1:57 AM, olcott wrote:
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
>   Output("Input_Halts = ", D(D));
> }
>
> *This is a key fact that I cannot possibly be gaslighted on* !!!
> H correctly determines that D correctly simulated by H cannot possibly
> reach its own return statement, then H aborts this simulation and
> correctly returns 0 for non-halting.
>
>
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

The halting problem is a decision problem about properties of computer
programs on a fixed Turing-complete model of computation, i.e., all
programs that can be written in some given programming language that is
general enough to be equivalent to a Turing machine. The problem is to
determine, given a program and an input to the program, whether the
program will eventually halt when run with that input. In this abstract
framework, there are no resource limitations on the amount of memory or
time required for the program's execution; it can take arbitrarily long
and use an arbitrary amount of storage space before halting. The
question is simply whether the given program will ever halt on a
particular input.

Thus the decider needs to tell us if the input program will run to
completion or run forever.

D(D) Halts since H(D,D) returns 0.

But, you claim, even by the definition above, that H is correct to call
a Halting Program non-halting because "????"

Your problem is that you just don't understand what the problem is, or
what the problem means.

You don't understand what truth actually is, but think you can redefine
it to meet your purposes.

In all, you are just shown to be a ignorant pathological lying idiot.

On 2/18/2023 12:57 AM, olcott wrote:
> int D(int (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H(D,D));
>   Output("Input_Halts = ", D(D));
> }
>
> *This is a key fact that I cannot possibly be gaslighted on* !!!
> H correctly determines that D correctly simulated by H cannot possibly
> reach its own return statement, then H aborts this simulation and
> correctly returns 0 for non-halting.
>
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H would reach its own final
state of ⟨Ĥ.qn⟩.

Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H would never reach its own
final state of ⟨Ĥ.qn⟩.

Additionally it is an easily verified fact that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
simulated by embedded_H would never reach its own final state ⟨Ĥ.qn⟩ in
any finite number of steps of correct simulation.

embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ that
copies its input and invokes embedded_H to simulate its input that
copies its input and invokes embedded_H to simulate its input that
copies its input and invokes embedded_H to simulate its input that
copies its input and invokes embedded_H to simulate its input ...
until embedded_H aborts the simulation and transitions to Ĥ.qn

The rebuttal to the Linz proof is explained on page 2 of this paper.

>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

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

On 2/18/23 11:36 AM, olcott wrote:
> On 2/18/2023 12:57 AM, olcott wrote:
>> int D(int (*x)())
>> {
>>    int Halt_Status = H(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(D,D));
>>    Output("Input_Halts = ", D(D));
>> }
>>
>> *This is a key fact that I cannot possibly be gaslighted on* !!!
>> H correctly determines that D correctly simulated by H cannot possibly
>> reach its own return statement, then H aborts this simulation and
>> correctly returns 0 for non-halting.
>>
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> If ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H would reach its own final
> state of ⟨Ĥ.qn⟩.

No, it is required to do that if ⟨Ĥ⟩ ⟨Ĥ⟩ when running reaches a final
state (which will be Ĥ.qn)

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> If ⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by embedded_H would never reach its own
> final state of ⟨Ĥ.qn⟩.

No it is required to do that if ⟨Ĥ⟩ ⟨Ĥ⟩ when running will never reach a
final state, even after an unbounded number of steps.

Read your problem statement.

It never mentions "simulations" at all, especially not by embedded_H,
which isn't even mentioned in the problem.

>
> Additionally it is an easily verified fact that ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
> simulated by embedded_H would never reach its own final state ⟨Ĥ.qn⟩ in
> any finite number of steps of correct simulation.

Nope, since you have stated that embedded_H WILL abort its simulation to
allow H to answer, we can see that a CORRECT simulation will reach that
final state, and that embedded_H never does a complete and correct
simulation.

>
> embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩ that
> copies its input and invokes embedded_H to simulate its input that
> copies its input and invokes embedded_H to simulate its input that
> copies its input and invokes embedded_H to simulate its input that
> copies its input and invokes embedded_H to simulate its input ...
> until embedded_H aborts the simulation and transitions to Ĥ.qn

And when embedded_H aborts its simulation and goes to H^.qn then H^ will
Halt, so H^ is a halting machine and embedded_H going to qn is an
incorrect answer.

>
> The rebuttal to the Linz proof is explained on page 2 of this paper.
>
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>

Which is full of errors, as has been pointed out.