int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional (otherwise impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution trace behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the
only actually open issue.
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional (otherwise impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution trace behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the
only actually open issue.
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional (otherwise
impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution trace
behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the
only actually open issue.
*I had to tighten my language a little bit*
Most of my reviewers deceptively talk about non-inputs when they already
know that deciders only operate on inputs.
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional (otherwise
impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution trace
behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps.
Most of my reviewers deceptively talk about non-inputs when they already
know that deciders only operate on inputs.
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional (otherwise >>> impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution trace >>> behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when correctly simulated by simulating halt decider H.
Most of my reviewers deceptively talk about non-inputs when they already
know that deciders only operate on inputs.
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution
trace
behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the >>>> only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input
machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts the above definition necessary requires that D simulated by H derives an execution trace that is not specified by its input...
Most of my reviewers deceptively talk about non-inputs when they already >>> know that deciders only operate on inputs.
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively proves
that D correctly simulated by H cannot possibly reach its own return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution
trace
behavior of the simulated input exactly matches the behavior that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is the >>>> only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input
machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts the above definition necessary requires that D simulated by H derives an execution trace that is not specified by its input...
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively proves >>>>> that D correctly simulated by H cannot possibly reach its own return >>>>> statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution
trace
behavior of the simulated input exactly matches the behavior that the >>>>> input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is
the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input >>> machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts the
above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction* Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively proves >>>>> that D correctly simulated by H cannot possibly reach its own return >>>>> statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution
trace
behavior of the simulated input exactly matches the behavior that the >>>>> input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through
dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem is
the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the input >>> machine description specifies then: It is an easily verified fact that
every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts the
above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction* Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively proves >>>>>> that D correctly simulated by H cannot possibly reach its own return >>>>>> statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution >>>>>> trace
behavior of the simulated input exactly matches the behavior that the >>>>>> input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem
is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the
input
machine description specifies then: It is an easily verified fact that >>>> every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when >>>> correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts the >>> above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt decider decides" relationship H does correctly determine the halt status
of the halting problem proof's previously impossible input.
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively proves >>>>>> that D correctly simulated by H cannot possibly reach its own return >>>>>> statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the execution >>>>>> trace
behavior of the simulated input exactly matches the behavior that the >>>>>> input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem
is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution
trace of the simulated input exactly matches the behavior that the
input
machine description specifies then: It is an easily verified fact that >>>> every counter-example input to the halting theorem D cannot possibly
reach its own simulated final state in any finite number of steps when >>>> correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts the >>> above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt decider decides" relationship H does correctly determine the halt status
of the halting problem proof's previously impossible input.
On 2/20/2023 9:28 PM, olcott wrote:
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively
proves
that D correctly simulated by H cannot possibly reach its own return >>>>>>> statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the
execution trace
behavior of the simulated input exactly matches the behavior that >>>>>>> the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem >>>>>>> is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution >>>>> trace of the simulated input exactly matches the behavior that the
input
machine description specifies then: It is an easily verified fact that >>>>> every counter-example input to the halting theorem D cannot possibly >>>>> reach its own simulated final state in any finite number of steps when >>>>> correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts
the
above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt
decider decides" relationship H does correctly determine the halt status
of the halting problem proof's previously impossible input.
Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.
The halting theorem does not prove that a set of input pairs cannot be divided into halting and not halting. It only proves that one criterion measure for dividing these pairs does not always work.
On 2/20/2023 9:28 PM, olcott wrote:
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively
proves
that D correctly simulated by H cannot possibly reach its own return >>>>>>> statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D
correctly simulated by H would ever reach its own final state.
The ultimate measure of a correct simulation is that the
execution trace
behavior of the simulated input exactly matches the behavior that >>>>>>> the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem >>>>>>> is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution >>>>> trace of the simulated input exactly matches the behavior that the
input
machine description specifies then: It is an easily verified fact that >>>>> every counter-example input to the halting theorem D cannot possibly >>>>> reach its own simulated final state in any finite number of steps when >>>>> correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that contradicts
the
above definition necessary requires that D simulated by H derives an
execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction*
Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt
decider decides" relationship H does correctly determine the halt status
of the halting problem proof's previously impossible input.
Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.
The halting theorem does not prove that a set of input pairs cannot be divided into halting and not halting. It only proves that one criterion measure for dividing these pairs does not always work.
On 2/20/2023 10:08 PM, olcott wrote:
On 2/20/2023 9:28 PM, olcott wrote:
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively >>>>>>>> proves
that D correctly simulated by H cannot possibly reach its own
return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D >>>>>>>> correctly simulated by H would ever reach its own final state. >>>>>>>>
The ultimate measure of a correct simulation is that the
execution trace
behavior of the simulated input exactly matches the behavior
that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem >>>>>>>> is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution >>>>>> trace of the simulated input exactly matches the behavior that the >>>>>> input
machine description specifies then: It is an easily verified fact
that
every counter-example input to the halting theorem D cannot possibly >>>>>> reach its own simulated final state in any finite number of steps
when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that
contradicts the
above definition necessary requires that D simulated by H derives an >>>>> execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction* >>>> Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt
decider decides" relationship H does correctly determine the halt status >>> of the halting problem proof's previously impossible input.
Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.
The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.
The halting theorem does not prove that a set of input pairs cannot be divided into halting and not halting. It only proves that one criterion measure for dividing these pairs does not always work.
*A famous theorem with a false conclusion ceases to be a famous theorem*
On 2/20/2023 10:08 PM, olcott wrote:
On 2/20/2023 9:28 PM, olcott wrote:
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional
(otherwise
impossible) input D ordinary software engineering conclusively >>>>>>>> proves
that D correctly simulated by H cannot possibly reach its own
return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D >>>>>>>> correctly simulated by H would ever reach its own final state. >>>>>>>>
The ultimate measure of a correct simulation is that the
execution trace
behavior of the simulated input exactly matches the behavior
that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting theorem >>>>>>>> is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the execution >>>>>> trace of the simulated input exactly matches the behavior that the >>>>>> input
machine description specifies then: It is an easily verified fact
that
every counter-example input to the halting theorem D cannot possibly >>>>>> reach its own simulated final state in any finite number of steps
when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that
contradicts the
above definition necessary requires that D simulated by H derives an >>>>> execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction* >>>> Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt
decider decides" relationship H does correctly determine the halt status >>> of the halting problem proof's previously impossible input.
Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.
The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.
The halting theorem does not prove that a set of input pairs cannot be divided into halting and not halting. It only proves that one criterion measure for dividing these pairs does not always work.
*A famous theorem with a false conclusion ceases to be a famous theorem*
On 2/20/2023 10:44 PM, olcott wrote:
On 2/20/2023 10:08 PM, olcott wrote:
On 2/20/2023 9:28 PM, olcott wrote:
On 2/20/2023 8:53 PM, olcott wrote:
On 2/20/2023 8:22 PM, olcott wrote:
On 2/20/2023 7:10 PM, olcott wrote:
On 2/20/2023 6:46 PM, olcott wrote:
On 2/20/2023 12:39 PM, olcott wrote:
int D(int (*x)())
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
When simulating halt decider H is applied to the conventional >>>>>>>>> (otherwise
impossible) input D ordinary software engineering conclusively >>>>>>>>> proves
that D correctly simulated by H cannot possibly reach its own >>>>>>>>> return
statement and terminate normally (AKA halt).
A simulating halt decider H correctly predicts whether or not D >>>>>>>>> correctly simulated by H would ever reach its own final state. >>>>>>>>>
The ultimate measure of a correct simulation is that the
execution trace
behavior of the simulated input exactly matches the behavior >>>>>>>>> that the
input machine code specifies.
https://www.researchgate.net/publication/368568464_Simulating_Halt_Deciders_Defeat_the_Halting_Theorem
Disagreeing with the above verified facts is only possible through >>>>>>>>> dishonesty or incompetence.
Whether or not the above directly applies to the halting
theorem is the
only actually open issue.
*I had to tighten my language a little bit*
When the ultimate measure of correct simulation is that the
execution
trace of the simulated input exactly matches the behavior that
the input
machine description specifies then: It is an easily verified fact >>>>>>> that
every counter-example input to the halting theorem D cannot possibly >>>>>>> reach its own simulated final state in any finite number of steps >>>>>>> when
correctly simulated by simulating halt decider H.
Any alternative definition for "correct simulation" that
contradicts the
above definition necessary requires that D simulated by H derives an >>>>>> execution trace that is not specified by its input...
Anyone with sufficient software engineering skill knows that
*D simulated by H cannot possibly correctly reach its ret instruction* >>>>> Everyone else lacks sufficient software engineering skill or lies
_D()
[00001d12] 55 push ebp
[00001d13] 8bec mov ebp,esp
[00001d15] 51 push ecx
[00001d16] 8b4508 mov eax,[ebp+08]
[00001d19] 50 push eax // push D
[00001d1a] 8b4d08 mov ecx,[ebp+08]
[00001d1d] 51 push ecx // push D
[00001d1e] e83ff8ffff call 00001562 // call H
[00001d23] 83c408 add esp,+08
[00001d26] 8945fc mov [ebp-04],eax
[00001d29] 837dfc00 cmp dword [ebp-04],+00
[00001d2d] 7402 jz 00001d31
[00001d2f] ebfe jmp 00001d2f
[00001d31] 8b45fc mov eax,[ebp-04]
[00001d34] 8be5 mov esp,ebp
[00001d36] 5d pop ebp
[00001d37] c3 ret
*THIS IS NOW A VERIFIED FACT*
Because H and D have the required "do the opposite of whatever the halt >>>> decider decides" relationship H does correctly determine the halt
status
of the halting problem proof's previously impossible input.
Now that the previously impossible input has been correctly determined
to be non-halting the halting theorem loses its entire basis.
The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.
The halting theorem does not prove that a set of input pairs cannot be
divided into halting and not halting. It only proves that one criterion
measure for dividing these pairs does not always work.
*A famous theorem with a false conclusion ceases to be a famous theorem*
The halting theorem does not prove that a set of input pairs cannot be divided into halting and not halting. It only proves that one criterion measure for dividing these pairs does not always work.
*A famous theorem with a false conclusion ceases to be a famous theorem*
It is a verified fact that H correctly predicts that D correctly
simulated by H would never reach its own final state and terminate
normally, thus H does correctly decide halting for its input D.
Every counter-example input to every proof of the halting theorem can be treated this same way.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 125:53:37 |
| Calls: | 6,663 |
| Calls today: | 1 |
| Files: | 12,212 |
| Messages: | 5,334,951 |