XPost: comp.theory, sci.logic, comp.software-eng

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic, comp.software-eng

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.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)