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
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
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.
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.
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.
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.
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.
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 365 |
Nodes: | 16 (2 / 14) |
Uptime: | 25:03:57 |
Calls: | 7,769 |
Files: | 12,905 |
Messages: | 5,749,272 |