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));
}

*Here is my current irrefutable reasoning*
H(D,D) does correctly compute the mapping from its input to its reject
state on the basis that H correctly predicts that D correctly simulated
by H would never halt (reach its own "return" statement and terminate
normally).

Everyone attempting to refute the above verified fact either
uses the strawman deception to change the subject away from
[D correctly simulated by H]
or flat out lies about the behavior of
[D correctly simulated by H]

*Complete halt deciding system* (Visual Studio Project)
https://liarparadox.org/2023_02_07.zip

*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/16/23 3:24 PM, 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));
> }
>
> *Here is my current irrefutable reasoning*
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the basis that H correctly predicts that D correctly simulated
> by H would never halt (reach its own "return" statement and terminate
> normally).
>
> Everyone attempting to refute the above verified fact either
> uses the strawman deception to change the subject away from
> [D correctly simulated by H]
> or flat out lies about the behavior of
> [D correctly simulated by H]
>
>
>
> *Complete halt deciding system* (Visual Studio Project)
> https://liarparadox.org/2023_02_07.zip
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

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.

D(D) Halts

H(D,D) says Non-Halting, thus it is NOT a "Correct Halting Decider of
Computabilyt Theory", and any claim it is can be clearly seen to be a LIE.

On 2/16/2023 2:24 PM, 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));
> }
>
> *Here is my current irrefutable reasoning*
> H(D,D) does correctly compute the mapping from its input to its reject
> state on the basis that H correctly predicts that D correctly simulated
> by H would never halt (reach its own "return" statement and terminate
> normally).
>
> Everyone attempting to refute the above verified fact either
> uses the strawman deception to change the subject away from
> [D correctly simulated by H]
> or flat out lies about the behavior of
> [D correctly simulated by H]
>
>
>
> *Complete halt deciding system* (Visual Studio Project)
> https://liarparadox.org/2023_02_07.zip
>
> *Simulating Halt Deciders Defeat the Halting Theorem*
> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>

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.

And it is universally understood (by the definition of a UTM) that D
correctly simulated by H necessarily demonstrates the actual behavior
specified by this input.

My reviewers already know this... yet disagree with verified facts
anyway so that they can play trollish head games.

--
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/16/23 9:03 PM, olcott wrote:
> On 2/16/2023 2:24 PM, 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));
>> }
>>
>> *Here is my current irrefutable reasoning*
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the basis that H correctly predicts that D correctly simulated
>> by H would never halt (reach its own "return" statement and terminate
>> normally).
>>
>> Everyone attempting to refute the above verified fact either
>> uses the strawman deception to change the subject away from
>> [D correctly simulated by H]
>> or flat out lies about the behavior of
>> [D correctly simulated by H]
>>
>>
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> https://liarparadox.org/2023_02_07.zip
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
> 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.
>
> And it is universally understood (by the definition of a UTM) that D
> correctly simulated by H necessarily demonstrates the actual behavior
> specified by this input.

And a UTM will ALWAYS continue simulating until it reaches a final state.

H doesn't do that, so H isn't a UTM, and thus H's simulation can not be
a substute for the actual execution of the input, or even the UTM
simulation of the input.

>
> My reviewers already know this... yet disagree with verified facts
> anyway so that they can play trollish head games.
>

No, it is a verified fact that the H that gives an answer is NOT a UTM,
and thus your claim that you can use its simulation is just a LIE.

Your continued instance just proves your ignorance.

The actual VERIIFED FACTS, which even you have agreed to is that D(D)
will Halt with your H that returns 0, which means non-halting from
H(D,D), and thus by the definition of a Halt Decider, the correct answer
is Halting,

It is also clear that you claims that Non-Halting is a "Correct Answer"
when you admit that the machine will actually Halt means you are just
LYING about what you are talking about.

PERIOD.

On 2/16/2023 8:03 PM, olcott wrote:
> On 2/16/2023 2:24 PM, 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));
>> }
>>
>> *Here is my current irrefutable reasoning*
>> H(D,D) does correctly compute the mapping from its input to its reject
>> state on the basis that H correctly predicts that D correctly simulated
>> by H would never halt (reach its own "return" statement and terminate
>> normally).
>>
>> Everyone attempting to refute the above verified fact either
>> uses the strawman deception to change the subject away from
>> [D correctly simulated by H]
>> or flat out lies about the behavior of
>> [D correctly simulated by H]
>>
>>
>>
>> *Complete halt deciding system* (Visual Studio Project)
>> https://liarparadox.org/2023_02_07.zip
>>
>> *Simulating Halt Deciders Defeat the Halting Theorem*
>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>
>
> 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.
>
> And it is universally understood (by the definition of a UTM) that D
> correctly simulated by H necessarily demonstrates the actual behavior
> specified by this input.
>

Therefore A halt decider H can be based on a UTM such that H continues
to simulate its input until H correctly determines that D correctly
simulated by H would never halt.

Because H is based on a UTM we know that the behavior that H is
evaluating is the behavior specified by its input.

--
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/17/23 9:24 AM, olcott wrote:
> On 2/16/2023 8:03 PM, olcott wrote:
>> On 2/16/2023 2:24 PM, 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));
>>> }
>>>
>>> *Here is my current irrefutable reasoning*
>>> H(D,D) does correctly compute the mapping from its input to its reject
>>> state on the basis that H correctly predicts that D correctly simulated
>>> by H would never halt (reach its own "return" statement and terminate
>>> normally).
>>>
>>> Everyone attempting to refute the above verified fact either
>>> uses the strawman deception to change the subject away from
>>> [D correctly simulated by H]
>>> or flat out lies about the behavior of
>>> [D correctly simulated by H]
>>>
>>>
>>>
>>> *Complete halt deciding system* (Visual Studio Project)
>>> https://liarparadox.org/2023_02_07.zip
>>>
>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>
>>
>> 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.
>>
>> And it is universally understood (by the definition of a UTM) that D
>> correctly simulated by H necessarily demonstrates the actual behavior
>> specified by this input.
>>
>
> Therefore A halt decider H can be based on a UTM such that H continues
> to simulate its input until H correctly determines that D correctly
> simulated by H would never halt.
>
> Because H is based on a UTM we know that the behavior that H is
> evaluating is the behavior specified by its input.
>

Not quite, H could use logic that H simulated its input until H could
corredctly determint that D correctly simulated BY A UTM would never halt.

But, because H isn't a UTM, since it DOES abort its simulation before
getting to an end, it is an error to assume that H is a UTM, or in
particular, that D calling H is calling a UTM.

All you have done is show that you don't understand the basics of
programming.

You whole "proof" is based on the LIE that H is just like a UTM, when it
isn't.

On 2/17/2023 8:24 AM, olcott wrote:
> On 2/16/2023 8:03 PM, olcott wrote:
>> On 2/16/2023 2:24 PM, 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));
>>> }
>>>
>>> *Here is my current irrefutable reasoning*
>>> H(D,D) does correctly compute the mapping from its input to its reject
>>> state on the basis that H correctly predicts that D correctly simulated
>>> by H would never halt (reach its own "return" statement and terminate
>>> normally).
>>>
>>> Everyone attempting to refute the above verified fact either
>>> uses the strawman deception to change the subject away from
>>> [D correctly simulated by H]
>>> or flat out lies about the behavior of
>>> [D correctly simulated by H]
>>>
>>>
>>>
>>> *Complete halt deciding system* (Visual Studio Project)
>>> https://liarparadox.org/2023_02_07.zip
>>>
>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>
>>
>> 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.
>>
>> And it is universally understood (by the definition of a UTM) that D
>> correctly simulated by H necessarily demonstrates the actual behavior
>> specified by this input.
>>
>
> Therefore A halt decider H can be based on a UTM such that H continues
> to simulate its input until H correctly determines that D correctly
> simulated by H would never halt.
>
> Because H is based on a UTM we know that the behavior that H is
> evaluating is the behavior specified by its input.
>

H acts like a UTM and simulates its input until H correctly determines
that D correctly simulated by H would never reach its own "return"
statement and terminate normally.

--
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/17/23 10:04 AM, olcott wrote:
> On 2/17/2023 8:24 AM, olcott wrote:
>> On 2/16/2023 8:03 PM, olcott wrote:
>>> On 2/16/2023 2:24 PM, 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));
>>>> }
>>>>
>>>> *Here is my current irrefutable reasoning*
>>>> H(D,D) does correctly compute the mapping from its input to its reject
>>>> state on the basis that H correctly predicts that D correctly simulated
>>>> by H would never halt (reach its own "return" statement and terminate
>>>> normally).
>>>>
>>>> Everyone attempting to refute the above verified fact either
>>>> uses the strawman deception to change the subject away from
>>>> [D correctly simulated by H]
>>>> or flat out lies about the behavior of
>>>> [D correctly simulated by H]
>>>>
>>>>
>>>>
>>>> *Complete halt deciding system* (Visual Studio Project)
>>>> https://liarparadox.org/2023_02_07.zip
>>>>
>>>> *Simulating Halt Deciders Defeat the Halting Theorem*
>>>> https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
>>>>
>>>
>>> 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.
>>>
>>> And it is universally understood (by the definition of a UTM) that D
>>> correctly simulated by H necessarily demonstrates the actual behavior
>>> specified by this input.
>>>
>>
>> Therefore A halt decider H can be based on a UTM such that H continues
>> to simulate its input until H correctly determines that D correctly
>> simulated by H would never halt.
>>
>> Because H is based on a UTM we know that the behavior that H is
>> evaluating is the behavior specified by its input.
>>
>
> H acts like a UTM and simulates its input until H correctly determines
> that D correctly simulated by H would never reach its own "return"
> statement and terminate normally.
>

No, if can't be "like a UTM until ..." that just isn't like a UTM.

That is like saying you are just like an immortal being until you die,
thus you can call yourself immortal.

You don't understand what being something means.

Maybe that is why you have at various times claimed to be "like God"
because you don't understand what that means.

You are not immortal, but maybe immoral due to your past history that
has been revealed.

H is NOT a Halt Decider, because 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.

Since D(D) has been shown to Halt, and you have even admittted that,
H(D,D) can NOT be a correct halt decider and say non-halting.

Either H isn't correct, or isn't a Halt Decider.

You claim that it is a correct halt decider is just proven to be a LIE
and shows that you are totally ignorant of the topic you are talking about.

On Friday, February 17, 2023 at 6:43:00 AM UTC-8, Richard Damon wrote:
> Not quite, H could use logic that H simulated its input until H could
> corredctly determint that D correctly simulated BY A UTM would never halt.
>
> But, because H isn't a UTM, since it DOES abort its simulation before
> getting to an end, it is an error to assume that H is a UTM, or in
> particular, that D calling H is calling a UTM.
>
But that H has a UTM embedded in it is PO's basic idea. This is why he
carefully says "simulating halt decider". What defeats this idea is the
fact that there might be no point in the simulated execution where it can
can be determined that the simulated execution is never going to halt.
H is a function and must halt.

On 2/17/23 6:53 PM, dklei...@gmail.com wrote:
> On Friday, February 17, 2023 at 6:43:00 AM UTC-8, Richard Damon wrote:
>> Not quite, H could use logic that H simulated its input until H could
>> corredctly determint that D correctly simulated BY A UTM would never halt.
>>
>> But, because H isn't a UTM, since it DOES abort its simulation before
>> getting to an end, it is an error to assume that H is a UTM, or in
>> particular, that D calling H is calling a UTM.
>>
> But that H has a UTM embedded in it is PO's basic idea. This is why he
> carefully says "simulating halt decider". What defeats this idea is the
> fact that there might be no point in the simulated execution where it can
> can be determined that the simulated execution is never going to halt.
> H is a function and must halt.

But it doesn't. It has a core that is BASED on a UTM, but includes code
that fundamentally changes its behavior by allowing it to stop.

The key point is that D calls the ACTUAL H, that is the one that DOES
abort its simulation and returns the non-halting decision.

H when it looks at D, persumes that the H that D calls is the
hypothetical non-aborting version, which isn't what it actually is.

Yes, for some other inputs, H can determine that if a UTM was simulating
the exact input that was given to H, that the UTM would not finish, and
in THAT case, H can abort its simulation and return non-halting.

That is NOT the logic being performed he. H is working on the logic that
it H was a different machine, including changing the copy of itself it
sees in the input, to something different, in that other universe, it
would not halt. But we aren't in that other universe, so that isn't a
valid bit of logic.

On 2/17/2023 5:53 PM, dklei...@gmail.com wrote:
> On Friday, February 17, 2023 at 6:43:00 AM UTC-8, Richard Damon wrote:
>> Not quite, H could use logic that H simulated its input until H could
>> corredctly determint that D correctly simulated BY A UTM would never halt.
>>
>> But, because H isn't a UTM, since it DOES abort its simulation before
>> getting to an end, it is an error to assume that H is a UTM, or in
>> particular, that D calling H is calling a UTM.
>>
> But that H has a UTM embedded in it is PO's basic idea. This is why he
> carefully says "simulating halt decider". What defeats this idea is the
> fact that there might be no point in the simulated execution where it can
> can be determined that the simulated execution is never going to halt.
> H is a function and must halt.

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.

--
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/17/23 10:40 PM, olcott wrote:
> On 2/17/2023 5:53 PM, dklei...@gmail.com wrote:
>> On Friday, February 17, 2023 at 6:43:00 AM UTC-8, Richard Damon wrote:
>>> Not quite, H could use logic that H simulated its input until H could
>>> corredctly determint that D correctly simulated BY A UTM would never
>>> halt.
>>>
>>> But, because H isn't a UTM, since it DOES abort its simulation before
>>> getting to an end, it is an error to assume that H is a UTM, or in
>>> particular, that D calling H is calling a UTM.
>>>
>> But that H has a UTM embedded in it is PO's basic idea. This is why he
>> carefully says "simulating halt decider". What defeats this idea is the
>> fact that there might be no point in the simulated execution where it can
>> can be determined that the simulated execution is never going to halt.
>> H is a function and must halt.
>
> 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.
>

But since 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.

And since D(D) does Halt, since H(D,D) has been shown to return 0, the
only CORRECT answer for a Halt Decider is Halting.

Since you say Non-Halting is a correct answer to you criteria, it
obviously can't be a criteria equivalent to Haltingt.

This shows that your whole arguement is built on a LIE about you working
on the Halting Problem, or that you are totally ignorant about what you
are talking about (or both).

The key point is that H isn't looking at or predicting what an actual
UTM simulation would do, means that the simulation it is deciding on
doesn't actually say anything about the actual Halting behavior of the
input.