Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)
void E(int (*x)())
{
HH(x, x);
return;
}
int main()
{
HH(E,E);
}
Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of steps. *Fully operational software linked below proves this*
*Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2023_02_07.zip
Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)
void E(int (*x)())
{
HH(x, x);
return;
}
int main()
{
HH(E,E);
}
Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of steps. *Fully operational software linked below proves this*
*Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2023_02_07.zip
Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)
void E(int (*x)())
{
HH(x, x);
return;
}
int main()
{
HH(E,E);
}
Two people with masters degrees in computer science have agreed that E correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of steps. *Fully operational software linked below proves this*
*Simulating Halt Decider Applied to the Halting Theorem* https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within Halt7.c
https://liarparadox.org/2023_02_07.zip
On 2/11/2023 9:21 PM, olcott wrote:
Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)
void E(int (*x)())
{
HH(x, x);
return;
}
int main()
{
HH(E,E);
}
Two people with masters degrees in computer science have agreed that E
correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps. *Fully operational software linked below proves this*
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within
Halt7.c
https://liarparadox.org/2023_02_07.zip
Because it is an easily verified fact that
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
cannot possibly halt
(reach its own "return" instruction and terminate normally)
It is necessarily correct for HH to abort its simulation of E and reject
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
as non-halting as soon as it detects the repeating state in
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
*straw man*
An intentionally misrepresented proposition that is set up because it is easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man
On 2/11/2023 9:21 PM, olcott wrote:
Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)
void E(int (*x)())
{
HH(x, x);
return;
}
int main()
{
HH(E,E);
}
Two people with masters degrees in computer science have agreed that E
correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps. *Fully operational software linked below proves this*
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within
Halt7.c
https://liarparadox.org/2023_02_07.zip
*Because it is an easily verified fact that*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
cannot possibly halt
(reach its own "return" instruction and terminate normally)
*HH is necessarily correct to abort its simulation of E and reject*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
*as non-halting as soon as it detects the repeating state in*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
*straw man*
An intentionally misrepresented proposition that is set up because it is easier to defeat than an opponent's real argument. https://www.lexico.com/en/definition/straw_man
On 2/12/2023 10:16 AM, olcott wrote:
On 2/11/2023 9:21 PM, olcott wrote:
Every E correctly simulated by any HH cannot possibly halt
(AKA reach its own return instruction and terminate normally)
void E(int (*x)())
{
HH(x, x);
return;
}
int main()
{
HH(E,E);
}
Two people with masters degrees in computer science have agreed that E
correctly simulated by HH cannot possibly reach its own "return"
instruction in any finite number of steps of correct simulation.
HH only needs to simulate E until HH correctly detects that E has a
repeating state such that E correctly simulated by HH cannot possibly
reach its own final state an terminate normally in any finite number of
steps. *Fully operational software linked below proves this*
*Simulating Halt Decider Applied to the Halting Theorem*
https://www.researchgate.net/publication/364657019_Simulating_Halt_Decider_Applied_to_the_Halting_Theorem
*Complete halt deciding system* (Visual Studio Project)
(a) x86utm operating system
(b) x86 emulator adapted from libx86emu to compile under Windows
(c) Several halt deciders and their sample inputs contained within
Halt7.c
https://liarparadox.org/2023_02_07.zip
*Because it is an easily verified fact that*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
cannot possibly halt
(reach its own "return" instruction and terminate normally)
*HH is necessarily correct to abort its simulation of E and reject*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
*as non-halting as soon as it detects the repeating state in*
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
The repeating state that we and HH can both see is that
E correctly simulated by HH
E correctly simulated by HH
E correctly simulated by HH
would continue to call HH(E,E) in recursive simulation
making it impossible for
E correctly simulated by H
E correctly simulated by H
E correctly simulated by H
to reach its own "return" instruction and terminate normally (AKA halt).
*straw man*
An intentionally misrepresented proposition that is set up because it is
easier to defeat than an opponent's real argument.
https://www.lexico.com/en/definition/straw_man
Sysop: | Keyop |
---|---|
Location: | Huddersfield, West Yorkshire, UK |
Users: | 366 |
Nodes: | 16 (2 / 14) |
Uptime: | 15:42:43 |
Calls: | 7,812 |
Files: | 12,927 |
Messages: | 5,766,124 |