On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>> of treatment that has an initial success rate much higher >>>>>>>>>>>>> than its non progression mortality rate.
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language
sufficiently well (thus not confused by the unreachable
"if" statement) correctly understands that DD simulated
by HHH cannot possibly reach its own return instruction.
And anyone that understand the halting problem knows that isn't >>>>>>>> the question being asked. The quesiton you NEED to ask is will >>>>>>>> the program described by the input halt when run?
Since you start off with the wrong question, you logic is just >>>>>>>> faulty.
Everyone that thinks my question is incorrect is wrong.
It has always been a mathematical mapping from finite
strings to behaviors. That people do not comprehend this
shows the shallowness of the depth of the learned-by-rote
(lack of) understanding.
No, you are just incorreect as you don't know what you are talking >>>>>> about.
Yes, it is a mapping of the string to the behavior, and that
mapping is DEFINED to be the halting behavior of the program the
string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider.
No, since the definition of "Halting Behavior" is the behavior of
the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>> of treatment that has an initial success rate much higher >>>>>>>>>>>>>>> than its non progression mortality rate.
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language
sufficiently well (thus not confused by the unreachable
"if" statement) correctly understands that DD simulated
by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>
And anyone that understand the halting problem knows that
isn't the question being asked. The quesiton you NEED to ask >>>>>>>>>> is will the program described by the input halt when run?
Since you start off with the wrong question, you logic is just >>>>>>>>>> faulty.
Everyone that thinks my question is incorrect is wrong.
It has always been a mathematical mapping from finite
strings to behaviors. That people do not comprehend this
shows the shallowness of the depth of the learned-by-rote
(lack of) understanding.
No, you are just incorreect as you don't know what you are
talking about.
Yes, it is a mapping of the string to the behavior, and that
mapping is DEFINED to be the halting behavior of the program the >>>>>>>> string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider.
No, since the definition of "Halting Behavior" is the behavior of
the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>> of treatment that has an initial success rate much higher >>>>>>>>>>>>>>> than its non progression mortality rate.
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language
sufficiently well (thus not confused by the unreachable
"if" statement) correctly understands that DD simulated
by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>
And anyone that understand the halting problem knows that
isn't the question being asked. The quesiton you NEED to ask >>>>>>>>>> is will the program described by the input halt when run?
Since you start off with the wrong question, you logic is just >>>>>>>>>> faulty.
Everyone that thinks my question is incorrect is wrong.
It has always been a mathematical mapping from finite
strings to behaviors. That people do not comprehend this
shows the shallowness of the depth of the learned-by-rote
(lack of) understanding.
No, you are just incorreect as you don't know what you are
talking about.
Yes, it is a mapping of the string to the behavior, and that
mapping is DEFINED to be the halting behavior of the program the >>>>>>>> string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider.
No, since the definition of "Halting Behavior" is the behavior of
the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>> of treatment that has an initial success rate much higher >>>>>>>>>>>>>>> than its non progression mortality rate.
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language
sufficiently well (thus not confused by the unreachable
"if" statement) correctly understands that DD simulated
by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>
And anyone that understand the halting problem knows that
isn't the question being asked. The quesiton you NEED to ask >>>>>>>>>> is will the program described by the input halt when run?
Since you start off with the wrong question, you logic is just >>>>>>>>>> faulty.
Everyone that thinks my question is incorrect is wrong.
It has always been a mathematical mapping from finite
strings to behaviors. That people do not comprehend this
shows the shallowness of the depth of the learned-by-rote
(lack of) understanding.
No, you are just incorreect as you don't know what you are
talking about.
Yes, it is a mapping of the string to the behavior, and that
mapping is DEFINED to be the halting behavior of the program the >>>>>>>> string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider.
No, since the definition of "Halting Behavior" is the behavior of
the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
Op 08.feb.2025 om 06:53 schreef olcott:
If so, then it proves the failure of the simulation. The simulation
aborts too soon on unsound grounds, one cycle before the normal
termination of the program.
On 2/8/2025 5:48 AM, Richard Damon wrote:Ever heard of bugs?
On 2/8/25 12:53 AM, olcott wrote:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
The source-code of DD and HHH specifies that DD calls HHH in recursive simulation making it impossible for DD to terminate normally. https://github.com/plolcott/x86utm/blob/master/Halt7.c Disagreeing with source-code is not a smart thing to do.
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>>>> of treatment that has an initial success rate much higher >>>>>>>>>>>>>>>>> than its non progression mortality rate.
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language
sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>
And anyone that understand the halting problem knows that >>>>>>>>>>>> isn't the question being asked. The quesiton you NEED to ask >>>>>>>>>>>> is will the program described by the input halt when run? >>>>>>>>>>>>
Since you start off with the wrong question, you logic is >>>>>>>>>>>> just faulty.
Everyone that thinks my question is incorrect is wrong.
It has always been a mathematical mapping from finite
strings to behaviors. That people do not comprehend this >>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you are >>>>>>>>>> talking about.
Yes, it is a mapping of the string to the behavior, and that >>>>>>>>>> mapping is DEFINED to be the halting behavior of the program >>>>>>>>>> the string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider.
No, since the definition of "Halting Behavior" is the behavior >>>>>>>> of the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The simulation
aborts too soon on unsound grounds, one cycle before the normal
termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
On 2/8/2025 5:48 AM, Richard Damon wrote:
On 2/8/25 12:53 AM, olcott wrote:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>>>> of treatment that has an initial success rate much higher >>>>>>>>>>>>>>>>> than its non progression mortality rate.
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language
sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>
And anyone that understand the halting problem knows that >>>>>>>>>>>> isn't the question being asked. The quesiton you NEED to ask >>>>>>>>>>>> is will the program described by the input halt when run? >>>>>>>>>>>>
Since you start off with the wrong question, you logic is >>>>>>>>>>>> just faulty.
Everyone that thinks my question is incorrect is wrong.
It has always been a mathematical mapping from finite
strings to behaviors. That people do not comprehend this >>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you are >>>>>>>>>> talking about.
Yes, it is a mapping of the string to the behavior, and that >>>>>>>>>> mapping is DEFINED to be the halting behavior of the program >>>>>>>>>> the string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider.
No, since the definition of "Halting Behavior" is the behavior >>>>>>>> of the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
WHere do you get your definition.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
The source-code of DD and HHH specifies that DD calls
HHH in recursive simulation making it impossible for DD
to terminate normally.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
Disagreeing with source-code is not a smart thing to do.
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>>>>>> of treatment that has an initial success rate much >>>>>>>>>>>>>>>>>>> higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>> sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>>>
And anyone that understand the halting problem knows that >>>>>>>>>>>>>> isn't the question being asked. The quesiton you NEED to >>>>>>>>>>>>>> ask is will the program described by the input halt when run? >>>>>>>>>>>>>>
Since you start off with the wrong question, you logic is >>>>>>>>>>>>>> just faulty.
Everyone that thinks my question is incorrect is wrong. >>>>>>>>>>>>> It has always been a mathematical mapping from finite >>>>>>>>>>>>> strings to behaviors. That people do not comprehend this >>>>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you are >>>>>>>>>>>> talking about.
Yes, it is a mapping of the string to the behavior, and that >>>>>>>>>>>> mapping is DEFINED to be the halting behavior of the program >>>>>>>>>>>> the string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider. >>>>>>>>>>>
No, since the definition of "Halting Behavior" is the behavior >>>>>>>>>> of the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The simulation
aborts too soon on unsound grounds, one cycle before the normal
termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about DD's
halting behaviour. All other methods (direct execution, simulation by
a world class simulator, etc.) show that DD halts. But HHH fails to
see it. Everyone with sufficient understanding of programming sees
that HHH is not correctly programmed when it aborts one cycle before
the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
This treatment does not typically last very long and >>>>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>>>>>> of treatment that has an initial success rate much >>>>>>>>>>>>>>>>>>> higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>> sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>>>
And anyone that understand the halting problem knows that >>>>>>>>>>>>>> isn't the question being asked. The quesiton you NEED to >>>>>>>>>>>>>> ask is will the program described by the input halt when run? >>>>>>>>>>>>>>
Since you start off with the wrong question, you logic is >>>>>>>>>>>>>> just faulty.
Everyone that thinks my question is incorrect is wrong. >>>>>>>>>>>>> It has always been a mathematical mapping from finite >>>>>>>>>>>>> strings to behaviors. That people do not comprehend this >>>>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you are >>>>>>>>>>>> talking about.
Yes, it is a mapping of the string to the behavior, and that >>>>>>>>>>>> mapping is DEFINED to be the halting behavior of the program >>>>>>>>>>>> the string describes.
No this is incorrect. The input finite string specifies
(not merely describes) non halting behavior to its decider. >>>>>>>>>>>
No, since the definition of "Halting Behavior" is the behavior >>>>>>>>>> of the progran being run.
It may seem that way to people that have learned-by-rote
as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of
running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The simulation
aborts too soon on unsound grounds, one cycle before the normal
termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about DD's
halting behaviour. All other methods (direct execution, simulation by
a world class simulator, etc.) show that DD halts. But HHH fails to
see it. Everyone with sufficient understanding of programming sees
that HHH is not correctly programmed when it aborts one cycle before
the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
If you have no idea what recursion is you will not be
able to understand what I am saying.
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very long and >>>>>>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth line >>>>>>>>>>>>>>>>>>>>> of treatment that has an initial success rate much >>>>>>>>>>>>>>>>>>>>> higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify non-halting >>>>>>>>>>>>>>>>>>> behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>>>>>
And anyone that understand the halting problem knows >>>>>>>>>>>>>>>> that isn't the question being asked. The quesiton you >>>>>>>>>>>>>>>> NEED to ask is will the program described by the input >>>>>>>>>>>>>>>> halt when run?
Since you start off with the wrong question, you logic >>>>>>>>>>>>>>>> is just faulty.
Everyone that thinks my question is incorrect is wrong. >>>>>>>>>>>>>>> It has always been a mathematical mapping from finite >>>>>>>>>>>>>>> strings to behaviors. That people do not comprehend this >>>>>>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you are >>>>>>>>>>>>>> talking about.
Yes, it is a mapping of the string to the behavior, and >>>>>>>>>>>>>> that mapping is DEFINED to be the halting behavior of the >>>>>>>>>>>>>> program the string describes.
No this is incorrect. The input finite string specifies >>>>>>>>>>>>> (not merely describes) non halting behavior to its decider. >>>>>>>>>>>>>
No, since the definition of "Halting Behavior" is the
behavior of the progran being run.
It may seem that way to people that have learned-by-rote >>>>>>>>>>> as their only basis. It is actually nothing like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings
specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior of >>>>>>>> running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The
simulation aborts too soon on unsound grounds, one cycle before
the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about DD's
halting behaviour. All other methods (direct execution, simulation
by a world class simulator, etc.) show that DD halts. But HHH fails
to see it. Everyone with sufficient understanding of programming
sees that HHH is not correctly programmed when it aborts one cycle
before the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete its
simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD.
That you can't understand this code proves that you lack the
technical basis to review my work.
On 2/8/2025 12:11 PM, joes wrote:
Am Sat, 08 Feb 2025 08:59:11 -0600 schrieb olcott:
On 2/8/2025 5:48 AM, Richard Damon wrote:Ever heard of bugs?
On 2/8/25 12:53 AM, olcott wrote:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote:
Am 05.02.2025 um 16:11 schrieb olcott:
On 2/5/2025 1:44 AM, Bonita Montero wrote:
Am 05.02.2025 um 04:38 schrieb olcott:
The source-code of DD and HHH specifies that DD calls HHH in recursive
simulation making it impossible for DD to terminate normally.
https://github.com/plolcott/x86utm/blob/master/Halt7.c Disagreeing with
source-code is not a smart thing to do.
No one has ever pointed out any actual bug in
my code in all of the years that it has been presented.
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:No, that *IS* the definition.
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very long and >>>>>>>>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth >>>>>>>>>>>>>>>>>>>>>>> line
of treatment that has an initial success rate >>>>>>>>>>>>>>>>>>>>>>> much higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify non- >>>>>>>>>>>>>>>>>>>>> halting
behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>>>>>>>
And anyone that understand the halting problem knows >>>>>>>>>>>>>>>>>> that isn't the question being asked. The quesiton you >>>>>>>>>>>>>>>>>> NEED to ask is will the program described by the input >>>>>>>>>>>>>>>>>> halt when run?
Since you start off with the wrong question, you logic >>>>>>>>>>>>>>>>>> is just faulty.
Everyone that thinks my question is incorrect is wrong. >>>>>>>>>>>>>>>>> It has always been a mathematical mapping from finite >>>>>>>>>>>>>>>>> strings to behaviors. That people do not comprehend this >>>>>>>>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you >>>>>>>>>>>>>>>> are talking about.
Yes, it is a mapping of the string to the behavior, and >>>>>>>>>>>>>>>> that mapping is DEFINED to be the halting behavior of >>>>>>>>>>>>>>>> the program the string describes.
No this is incorrect. The input finite string specifies >>>>>>>>>>>>>>> (not merely describes) non halting behavior to its decider. >>>>>>>>>>>>>>>
No, since the definition of "Halting Behavior" is the >>>>>>>>>>>>>> behavior of the progran being run.
It may seem that way to people that have learned-by-rote >>>>>>>>>>>>> as their only basis. It is actually nothing like that. >>>>>>>>>>>>
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings >>>>>>>>>>> specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior >>>>>>>>>> of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The
simulation aborts too soon on unsound grounds, one cycle before >>>>>>>> the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about DD's
halting behaviour. All other methods (direct execution, simulation >>>>>> by a world class simulator, etc.) show that DD halts. But HHH
fails to see it. Everyone with sufficient understanding of
programming sees that HHH is not correctly programmed when it
aborts one cycle before the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete its
simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD.
That you can't understand this code proves that you lack the
technical basis to review my work.
It turns out that Olcott does not even understand this simple proof
that HHH produces false negatives. HHH is unable to simulate itself up
to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that
your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:No, that *IS* the definition.
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote:
On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very long and >>>>>>>>>>>>>>>>>>>>>>> will be immediately followed by a riskier fourth >>>>>>>>>>>>>>>>>>>>>>> line
of treatment that has an initial success rate >>>>>>>>>>>>>>>>>>>>>>> much higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify non- >>>>>>>>>>>>>>>>>>>>> halting
behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the unreachable >>>>>>>>>>>>>>>>>>> "if" statement) correctly understands that DD simulated >>>>>>>>>>>>>>>>>>> by HHH cannot possibly reach its own return instruction. >>>>>>>>>>>>>>>>>>>
And anyone that understand the halting problem knows >>>>>>>>>>>>>>>>>> that isn't the question being asked. The quesiton you >>>>>>>>>>>>>>>>>> NEED to ask is will the program described by the input >>>>>>>>>>>>>>>>>> halt when run?
Since you start off with the wrong question, you logic >>>>>>>>>>>>>>>>>> is just faulty.
Everyone that thinks my question is incorrect is wrong. >>>>>>>>>>>>>>>>> It has always been a mathematical mapping from finite >>>>>>>>>>>>>>>>> strings to behaviors. That people do not comprehend this >>>>>>>>>>>>>>>>> shows the shallowness of the depth of the learned-by-rote >>>>>>>>>>>>>>>>> (lack of) understanding.
No, you are just incorreect as you don't know what you >>>>>>>>>>>>>>>> are talking about.
Yes, it is a mapping of the string to the behavior, and >>>>>>>>>>>>>>>> that mapping is DEFINED to be the halting behavior of >>>>>>>>>>>>>>>> the program the string describes.
No this is incorrect. The input finite string specifies >>>>>>>>>>>>>>> (not merely describes) non halting behavior to its decider. >>>>>>>>>>>>>>>
No, since the definition of "Halting Behavior" is the >>>>>>>>>>>>>> behavior of the progran being run.
It may seem that way to people that have learned-by-rote >>>>>>>>>>>>> as their only basis. It is actually nothing like that. >>>>>>>>>>>>
A termination analyzer computes the mapping from finite
strings to the actual behavior that these finite strings >>>>>>>>>>> specify. That this is not dead obvious to everyone here
merely proves that learned-by-rote does not involve any
actual comprehension.
And the behavior the finite string specifies is the behavior >>>>>>>>>> of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The
simulation aborts too soon on unsound grounds, one cycle before >>>>>>>> the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about DD's
halting behaviour. All other methods (direct execution, simulation >>>>>> by a world class simulator, etc.) show that DD halts. But HHH
fails to see it. Everyone with sufficient understanding of
programming sees that HHH is not correctly programmed when it
aborts one cycle before the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete its
simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD.
That you can't understand this code proves that you lack the
technical basis to review my work.
It turns out that Olcott does not even understand this simple proof
that HHH produces false negatives. HHH is unable to simulate itself up
to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that
your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:No, that *IS* the definition.
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote:
On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very >>>>>>>>>>>>>>>>>>>>>>>>> long and
will be immediately followed by a riskier >>>>>>>>>>>>>>>>>>>>>>>>> fourth line
of treatment that has an initial success rate >>>>>>>>>>>>>>>>>>>>>>>>> much higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify non- >>>>>>>>>>>>>>>>>>>>>>> halting
behavior to its decider.
https://www.researchgate.net/
publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the >>>>>>>>>>>>>>>>>>>>> unreachable
"if" statement) correctly understands that DD >>>>>>>>>>>>>>>>>>>>> simulated
by HHH cannot possibly reach its own return >>>>>>>>>>>>>>>>>>>>> instruction.
And anyone that understand the halting problem knows >>>>>>>>>>>>>>>>>>>> that isn't the question being asked. The quesiton >>>>>>>>>>>>>>>>>>>> you NEED to ask is will the program described by the >>>>>>>>>>>>>>>>>>>> input halt when run?
Since you start off with the wrong question, you >>>>>>>>>>>>>>>>>>>> logic is just faulty.
Everyone that thinks my question is incorrect is wrong. >>>>>>>>>>>>>>>>>>> It has always been a mathematical mapping from finite >>>>>>>>>>>>>>>>>>> strings to behaviors. That people do not comprehend this >>>>>>>>>>>>>>>>>>> shows the shallowness of the depth of the learned-by- >>>>>>>>>>>>>>>>>>> rote
(lack of) understanding.
No, you are just incorreect as you don't know what you >>>>>>>>>>>>>>>>>> are talking about.
Yes, it is a mapping of the string to the behavior, >>>>>>>>>>>>>>>>>> and that mapping is DEFINED to be the halting behavior >>>>>>>>>>>>>>>>>> of the program the string describes.
No this is incorrect. The input finite string specifies >>>>>>>>>>>>>>>>> (not merely describes) non halting behavior to its >>>>>>>>>>>>>>>>> decider.
No, since the definition of "Halting Behavior" is the >>>>>>>>>>>>>>>> behavior of the progran being run.
It may seem that way to people that have learned-by-rote >>>>>>>>>>>>>>> as their only basis. It is actually nothing like that. >>>>>>>>>>>>>>
A termination analyzer computes the mapping from finite >>>>>>>>>>>>> strings to the actual behavior that these finite strings >>>>>>>>>>>>> specify. That this is not dead obvious to everyone here >>>>>>>>>>>>> merely proves that learned-by-rote does not involve any >>>>>>>>>>>>> actual comprehension.
And the behavior the finite string specifies is the behavior >>>>>>>>>>>> of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The
simulation aborts too soon on unsound grounds, one cycle
before the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about
DD's halting behaviour. All other methods (direct execution,
simulation by a world class simulator, etc.) show that DD halts. >>>>>>>> But HHH fails to see it. Everyone with sufficient understanding >>>>>>>> of programming sees that HHH is not correctly programmed when it >>>>>>>> aborts one cycle before the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete its
simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD.
That you can't understand this code proves that you lack the
technical basis to review my work.
It turns out that Olcott does not even understand this simple proof
that HHH produces false negatives. HHH is unable to simulate itself
up to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that
your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he tries
to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly
simulated by HHH until its normal termination.
If you believe
otherwise this merely proves that you do not understand
what recursion is and how it works.
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:No, that *IS* the definition.
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very >>>>>>>>>>>>>>>>>>>>>>>>>>> long and
will be immediately followed by a riskier >>>>>>>>>>>>>>>>>>>>>>>>>>> fourth line
of treatment that has an initial success rate >>>>>>>>>>>>>>>>>>>>>>>>>>> much higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify >>>>>>>>>>>>>>>>>>>>>>>>> non- halting
behavior to its decider.
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the >>>>>>>>>>>>>>>>>>>>>>> unreachable
"if" statement) correctly understands that DD >>>>>>>>>>>>>>>>>>>>>>> simulated
by HHH cannot possibly reach its own return >>>>>>>>>>>>>>>>>>>>>>> instruction.
And anyone that understand the halting problem >>>>>>>>>>>>>>>>>>>>>> knows that isn't the question being asked. The >>>>>>>>>>>>>>>>>>>>>> quesiton you NEED to ask is will the program >>>>>>>>>>>>>>>>>>>>>> described by the input halt when run? >>>>>>>>>>>>>>>>>>>>>>
Since you start off with the wrong question, you >>>>>>>>>>>>>>>>>>>>>> logic is just faulty.
Everyone that thinks my question is incorrect is >>>>>>>>>>>>>>>>>>>>> wrong.
It has always been a mathematical mapping from finite >>>>>>>>>>>>>>>>>>>>> strings to behaviors. That people do not comprehend >>>>>>>>>>>>>>>>>>>>> this
shows the shallowness of the depth of the learned- >>>>>>>>>>>>>>>>>>>>> by- rote
(lack of) understanding.
No, you are just incorreect as you don't know what >>>>>>>>>>>>>>>>>>>> you are talking about.
Yes, it is a mapping of the string to the behavior, >>>>>>>>>>>>>>>>>>>> and that mapping is DEFINED to be the halting >>>>>>>>>>>>>>>>>>>> behavior of the program the string describes. >>>>>>>>>>>>>>>>>>>>
No this is incorrect. The input finite string specifies >>>>>>>>>>>>>>>>>>> (not merely describes) non halting behavior to its >>>>>>>>>>>>>>>>>>> decider.
No, since the definition of "Halting Behavior" is the >>>>>>>>>>>>>>>>>> behavior of the progran being run.
It may seem that way to people that have learned-by-rote >>>>>>>>>>>>>>>>> as their only basis. It is actually nothing like that. >>>>>>>>>>>>>>>>
A termination analyzer computes the mapping from finite >>>>>>>>>>>>>>> strings to the actual behavior that these finite strings >>>>>>>>>>>>>>> specify. That this is not dead obvious to everyone here >>>>>>>>>>>>>>> merely proves that learned-by-rote does not involve any >>>>>>>>>>>>>>> actual comprehension.
And the behavior the finite string specifies is the >>>>>>>>>>>>>> behavior of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The >>>>>>>>>>>> simulation aborts too soon on unsound grounds, one cycle >>>>>>>>>>>> before the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about >>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>> simulation by a world class simulator, etc.) show that DD
halts. But HHH fails to see it. Everyone with sufficient
understanding of programming sees that HHH is not correctly >>>>>>>>>> programmed when it aborts one cycle before the simulation
would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete
its simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD. >>>>>>>
That you can't understand this code proves that you lack the
technical basis to review my work.
It turns out that Olcott does not even understand this simple
proof that HHH produces false negatives. HHH is unable to simulate >>>>>> itself up to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that
your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he tries
to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly
simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly.
If this was true then you could point out exactly where HHH
is incorrect. Because this is not true and you don't hardly
understand these things at all your rebuttals are mere dogmatic
assertions with no basis in actual reasoning what-so-ever.
Here is the code point out the (nonexistent) error: https://github.com/plolcott/x86utm/blob/master/Halt7.c
It produces false negatives. Such a failing HHH cannot be used for the
halting problem.
If you believe
otherwise this merely proves that you do not understand
what recursion is and how it works.
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:No, that *IS* the definition.
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very >>>>>>>>>>>>>>>>>>>>>>>>>>> long and
will be immediately followed by a riskier >>>>>>>>>>>>>>>>>>>>>>>>>>> fourth line
of treatment that has an initial success rate >>>>>>>>>>>>>>>>>>>>>>>>>>> much higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved !
The halting problem proof input does specify >>>>>>>>>>>>>>>>>>>>>>>>> non- halting
behavior to its decider.
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the >>>>>>>>>>>>>>>>>>>>>>> unreachable
"if" statement) correctly understands that DD >>>>>>>>>>>>>>>>>>>>>>> simulated
by HHH cannot possibly reach its own return >>>>>>>>>>>>>>>>>>>>>>> instruction.
And anyone that understand the halting problem >>>>>>>>>>>>>>>>>>>>>> knows that isn't the question being asked. The >>>>>>>>>>>>>>>>>>>>>> quesiton you NEED to ask is will the program >>>>>>>>>>>>>>>>>>>>>> described by the input halt when run? >>>>>>>>>>>>>>>>>>>>>>
Since you start off with the wrong question, you >>>>>>>>>>>>>>>>>>>>>> logic is just faulty.
Everyone that thinks my question is incorrect is >>>>>>>>>>>>>>>>>>>>> wrong.
It has always been a mathematical mapping from finite >>>>>>>>>>>>>>>>>>>>> strings to behaviors. That people do not comprehend >>>>>>>>>>>>>>>>>>>>> this
shows the shallowness of the depth of the learned- >>>>>>>>>>>>>>>>>>>>> by- rote
(lack of) understanding.
No, you are just incorreect as you don't know what >>>>>>>>>>>>>>>>>>>> you are talking about.
Yes, it is a mapping of the string to the behavior, >>>>>>>>>>>>>>>>>>>> and that mapping is DEFINED to be the halting >>>>>>>>>>>>>>>>>>>> behavior of the program the string describes. >>>>>>>>>>>>>>>>>>>>
No this is incorrect. The input finite string specifies >>>>>>>>>>>>>>>>>>> (not merely describes) non halting behavior to its >>>>>>>>>>>>>>>>>>> decider.
No, since the definition of "Halting Behavior" is the >>>>>>>>>>>>>>>>>> behavior of the progran being run.
It may seem that way to people that have learned-by-rote >>>>>>>>>>>>>>>>> as their only basis. It is actually nothing like that. >>>>>>>>>>>>>>>>
A termination analyzer computes the mapping from finite >>>>>>>>>>>>>>> strings to the actual behavior that these finite strings >>>>>>>>>>>>>>> specify. That this is not dead obvious to everyone here >>>>>>>>>>>>>>> merely proves that learned-by-rote does not involve any >>>>>>>>>>>>>>> actual comprehension.
And the behavior the finite string specifies is the >>>>>>>>>>>>>> behavior of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace
than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The >>>>>>>>>>>> simulation aborts too soon on unsound grounds, one cycle >>>>>>>>>>>> before the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally
is a verified fact.
Which proves that HHH fails to make a correct decision about >>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>> simulation by a world class simulator, etc.) show that DD
halts. But HHH fails to see it. Everyone with sufficient
understanding of programming sees that HHH is not correctly >>>>>>>>>> programmed when it aborts one cycle before the simulation
would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete
its simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD. >>>>>>>
That you can't understand this code proves that you lack the
technical basis to review my work.
It turns out that Olcott does not even understand this simple
proof that HHH produces false negatives. HHH is unable to simulate >>>>>> itself up to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that
your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he tries
to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly
simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly.
If this was true then you could point out exactly where HHH
is incorrect.
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct value.
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote:
On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote:
On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
So, in other words, Olcott denies verified facts.It turns out that Olcott does not even understand this simple proof >>>>>> that HHH produces false negatives. HHH is unable to simulate itself >>>>>> up to the normal termination.Which proves that HHH fails to make a correct decision about >>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>> simulation by a world class simulator, etc.) show that DD
halts. But HHH fails to see it. Everyone with sufficient
understanding of programming sees that HHH is not correctly >>>>>>>>>> programmed when it aborts one cycle before the simulation would >>>>>>>>>> end normally.
The execution trace only shows that HHH is unable to complete its >>>>>>>> simulation, because HHH is unable to simulate itself.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he tries
to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly simulated
by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly.
If this was true then you could point out exactly where HHH is
incorrect.
Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:No, that *IS* the definition.
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last very >>>>>>>>>>>>>>>>>>>>>>>>>>>>> long and
will be immediately followed by a riskier >>>>>>>>>>>>>>>>>>>>>>>>>>>>> fourth line
of treatment that has an initial success >>>>>>>>>>>>>>>>>>>>>>>>>>>>> rate much higher
than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved ! >>>>>>>>>>>>>>>>>>>>>>>>>>>>
The halting problem proof input does specify >>>>>>>>>>>>>>>>>>>>>>>>>>> non- halting
behavior to its decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming language >>>>>>>>>>>>>>>>>>>>>>>>> sufficiently well (thus not confused by the >>>>>>>>>>>>>>>>>>>>>>>>> unreachable
"if" statement) correctly understands that DD >>>>>>>>>>>>>>>>>>>>>>>>> simulated
by HHH cannot possibly reach its own return >>>>>>>>>>>>>>>>>>>>>>>>> instruction.
And anyone that understand the halting problem >>>>>>>>>>>>>>>>>>>>>>>> knows that isn't the question being asked. The >>>>>>>>>>>>>>>>>>>>>>>> quesiton you NEED to ask is will the program >>>>>>>>>>>>>>>>>>>>>>>> described by the input halt when run? >>>>>>>>>>>>>>>>>>>>>>>>
Since you start off with the wrong question, you >>>>>>>>>>>>>>>>>>>>>>>> logic is just faulty.
Everyone that thinks my question is incorrect is >>>>>>>>>>>>>>>>>>>>>>> wrong.
It has always been a mathematical mapping from >>>>>>>>>>>>>>>>>>>>>>> finite
strings to behaviors. That people do not >>>>>>>>>>>>>>>>>>>>>>> comprehend this
shows the shallowness of the depth of the >>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
(lack of) understanding.
No, you are just incorreect as you don't know what >>>>>>>>>>>>>>>>>>>>>> you are talking about.
Yes, it is a mapping of the string to the >>>>>>>>>>>>>>>>>>>>>> behavior, and that mapping is DEFINED to be the >>>>>>>>>>>>>>>>>>>>>> halting behavior of the program the string describes. >>>>>>>>>>>>>>>>>>>>>>
No this is incorrect. The input finite string >>>>>>>>>>>>>>>>>>>>> specifies
(not merely describes) non halting behavior to its >>>>>>>>>>>>>>>>>>>>> decider.
No, since the definition of "Halting Behavior" is >>>>>>>>>>>>>>>>>>>> the behavior of the progran being run. >>>>>>>>>>>>>>>>>>>>
It may seem that way to people that have learned-by-rote >>>>>>>>>>>>>>>>>>> as their only basis. It is actually nothing like that. >>>>>>>>>>>>>>>>>>
A termination analyzer computes the mapping from finite >>>>>>>>>>>>>>>>> strings to the actual behavior that these finite strings >>>>>>>>>>>>>>>>> specify. That this is not dead obvious to everyone here >>>>>>>>>>>>>>>>> merely proves that learned-by-rote does not involve any >>>>>>>>>>>>>>>>> actual comprehension.
And the behavior the finite string specifies is the >>>>>>>>>>>>>>>> behavior of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace >>>>>>>>>>>>>>> than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The >>>>>>>>>>>>>> simulation aborts too soon on unsound grounds, one cycle >>>>>>>>>>>>>> before the normal termination of the program.
This proves that you simply don't have sufficient
understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally >>>>>>>>>>>>> is a verified fact.
Which proves that HHH fails to make a correct decision about >>>>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>>>> simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>> programmed when it aborts one cycle before the simulation >>>>>>>>>>>> would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD...
The execution trace only shows that HHH is unable to complete >>>>>>>>>> its simulation, because HHH is unable to simulate itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself simulating DD. >>>>>>>>>
That you can't understand this code proves that you lack the >>>>>>>>> technical basis to review my work.
It turns out that Olcott does not even understand this simple
proof that HHH produces false negatives. HHH is unable to
simulate itself up to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that
your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he
tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly
simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly.
If this was true then you could point out exactly where HHH
is incorrect.
It is true as a verified fact and has been pointed out to Olcott many
times, but he refuses to learn. So, again:
It is a verified fact that main halts,
It is a verified fact that the input to HHH(main) cannot
possibly terminate normally.
The strawman error <is> an error.
On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
So, in other words, Olcott denies verified facts.It turns out that Olcott does not even understand this simple proof >>>>>>>> that HHH produces false negatives. HHH is unable to simulate itself >>>>>>>> up to the normal termination.Which proves that HHH fails to make a correct decision about >>>>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>>>> simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>> programmed when it aborts one cycle before the simulation would >>>>>>>>>>>> end normally.
The execution trace only shows that HHH is unable to complete its >>>>>>>>>> simulation, because HHH is unable to simulate itself.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he tries >>>>>> to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly simulated >>>>> by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly.
If this was true then you could point out exactly where HHH is
incorrect.
HHH is supposed to be a decider, i.e. halt and return the correct value.
The directly executed HHH(DD) always halts and returns a correct
value as soon as it correctly determines that its input cannot
possibly terminate normally.
Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
The directly executed main IS NOT THE INPUT TO HHH.
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:Yeah, if the input HHH doesn’t terminate, that is not a decider.
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
So, in other words, Olcott denies verified facts.It turns out that Olcott does not even understand this simplehttps://github.com/plolcott/x86utm/blob/master/Halt7.c The above >>>>>>>>> code proves that HHH does simulate itself simulating DD.Which proves that HHH fails to make a correct decision about >>>>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>>>> simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>> programmed when it aborts one cycle before the simulation >>>>>>>>>>>> would end normally.DD simulated by HHH cannot possibly terminate normally is a >>>>>>>>>>>>> verified fact.If so, then it proves the failure of the simulation. The >>>>>>>>>>>>>> simulation aborts too soon on unsound grounds, one cycle >>>>>>>>>>>>>> before the normal termination of the program.And the behavior the finite string specifies is the >>>>>>>>>>>>>>>> behavior of running the program.A termination analyzer computes the mapping from finite >>>>>>>>>>>>>>>>> strings to the actual behavior that these finite strings >>>>>>>>>>>>>>>>> specify.No, since the definition of "Halting Behavior" is the >>>>>>>>>>>>>>>>>>>> behavior of the progran being run.No this is incorrect. The input finite string >>>>>>>>>>>>>>>>>>>>> specifies (not merely describes) non halting >>>>>>>>>>>>>>>>>>>>> behavior to its decider.Yes, it is a mapping of the string to the behavior, >>>>>>>>>>>>>>>>>>>>>> and that mapping is DEFINED to be the halting >>>>>>>>>>>>>>>>>>>>>> behavior of the program the string describes. >>>>>>>>>>>>>>>>>>>>>>And anyone that understand the halting problem >>>>>>>>>>>>>>>>>>>>>>>> knows that isn't the question being asked. The >>>>>>>>>>>>>>>>>>>>>>>> quesiton you NEED to ask is will the program >>>>>>>>>>>>>>>>>>>>>>>> described by the input halt when run? >>>>>>>>>>>>>>>>>>>>>>>>It has always been a mathematical mapping from >>>>>>>>>>>>>>>>>>>>>>> finite strings to behaviors.
That is verifiably factually incorrect.
The running program has a different execution trace than >>>>>>>>>>>>>>> the behavior that DD specifies to HHH.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
The execution trace only shows that HHH is unable to complete >>>>>>>>>> its simulation, because HHH is unable to simulate itself.
proof that HHH produces false negatives. HHH is unable to
simulate itself up to the normal termination.
HHH generates false negatives, as is verified in
int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he
tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly
simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly.
If this was true then you could point out exactly where HHH is
incorrect.
It is true as a verified fact and has been pointed out to Olcott many
times, but he refuses to learn. So, again:
It is a verified fact that main halts,
It is a verified fact that the input to HHH(main) cannot possibly
terminate normally. The strawman error <is> an error.
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct value
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote:
On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote:
On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
If this was true then you could point out exactly where HHH isIndeed, which proves that HHH is unable to simulate itself correctly.It is a verified fact that main cannot possibly be correctlySo, in other words, Olcott denies verified facts.It turns out that Olcott does not even understand this simpleThe execution trace only shows that HHH is unable to complete >>>>>>>>>> its simulation, because HHH is unable to simulate itself.Which proves that HHH fails to make a correct decision about >>>>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>>>> simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>> programmed when it aborts one cycle before the simulation >>>>>>>>>>>> would end normally.
proof that HHH produces false negatives. HHH is unable to
simulate itself up to the normal termination.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he
tries to hide with a lot of irrelevant words.
simulated by HHH until its normal termination.
incorrect.
value.
as soon as it correctly determines that its input cannot possibly
terminate normally.
Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:Line 502.
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
If this was true then you could point out exactly where HHH isIt is a verified fact that main cannot possibly be correctlyIndeed, which proves that HHH is unable to simulate itself
simulated by HHH until its normal termination.
correctly.
incorrect.
It’s not? What if it were?The directly executed main IS NOT THE INPUT TO HHH.No, the verified fact is that the input can terminatie normallyIt is true as a verified fact and has been pointed out to Olcott manyIt is a verified fact that the input to HHH(main) cannot possibly
times, but he refuses to learn. So, again:
It is a verified fact that main halts,
terminate normally.
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where HHH
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:The execution trace only shows that HHH is unable to
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> very long andNo, that *IS* the definition.
will be immediately followed by a riskier >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fourth line
of treatment that has an initial success >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> rate much higher >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved ! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The halting problem proof input does >>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify non- halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to its decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming >>>>>>>>>>>>>>>>>>>>>>>>>>> language
sufficiently well (thus not confused by the >>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable
"if" statement) correctly understands that DD >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated
by HHH cannot possibly reach its own return >>>>>>>>>>>>>>>>>>>>>>>>>>> instruction.
And anyone that understand the halting problem >>>>>>>>>>>>>>>>>>>>>>>>>> knows that isn't the question being asked. The >>>>>>>>>>>>>>>>>>>>>>>>>> quesiton you NEED to ask is will the program >>>>>>>>>>>>>>>>>>>>>>>>>> described by the input halt when run? >>>>>>>>>>>>>>>>>>>>>>>>>>
Since you start off with the wrong question, >>>>>>>>>>>>>>>>>>>>>>>>>> you logic is just faulty.
Everyone that thinks my question is incorrect >>>>>>>>>>>>>>>>>>>>>>>>> is wrong.
It has always been a mathematical mapping from >>>>>>>>>>>>>>>>>>>>>>>>> finite
strings to behaviors. That people do not >>>>>>>>>>>>>>>>>>>>>>>>> comprehend this
shows the shallowness of the depth of the >>>>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
(lack of) understanding.
No, you are just incorreect as you don't know >>>>>>>>>>>>>>>>>>>>>>>> what you are talking about.
Yes, it is a mapping of the string to the >>>>>>>>>>>>>>>>>>>>>>>> behavior, and that mapping is DEFINED to be the >>>>>>>>>>>>>>>>>>>>>>>> halting behavior of the program the string >>>>>>>>>>>>>>>>>>>>>>>> describes.
No this is incorrect. The input finite string >>>>>>>>>>>>>>>>>>>>>>> specifies
(not merely describes) non halting behavior to >>>>>>>>>>>>>>>>>>>>>>> its decider.
No, since the definition of "Halting Behavior" is >>>>>>>>>>>>>>>>>>>>>> the behavior of the progran being run. >>>>>>>>>>>>>>>>>>>>>>
It may seem that way to people that have learned- >>>>>>>>>>>>>>>>>>>>> by- rote
as their only basis. It is actually nothing like that. >>>>>>>>>>>>>>>>>>>>
A termination analyzer computes the mapping from finite >>>>>>>>>>>>>>>>>>> strings to the actual behavior that these finite strings >>>>>>>>>>>>>>>>>>> specify. That this is not dead obvious to everyone here >>>>>>>>>>>>>>>>>>> merely proves that learned-by-rote does not involve any >>>>>>>>>>>>>>>>>>> actual comprehension.
And the behavior the finite string specifies is the >>>>>>>>>>>>>>>>>> behavior of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace >>>>>>>>>>>>>>>>> than the behavior that DD specifies to HHH.
If so, then it proves the failure of the simulation. The >>>>>>>>>>>>>>>> simulation aborts too soon on unsound grounds, one cycle >>>>>>>>>>>>>>>> before the normal termination of the program.
This proves that you simply don't have sufficient >>>>>>>>>>>>>>> understanding of the C programming language.
DD simulated by HHH cannot possibly terminate normally >>>>>>>>>>>>>>> is a verified fact.
Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>> execution, simulation by a world class simulator, etc.) >>>>>>>>>>>>>> show that DD halts. But HHH fails to see it. Everyone with >>>>>>>>>>>>>> sufficient understanding of programming sees that HHH is >>>>>>>>>>>>>> not correctly programmed when it aborts one cycle before >>>>>>>>>>>>>> the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD... >>>>>>>>>>>>
complete its simulation, because HHH is unable to simulate >>>>>>>>>>>> itself.
https://github.com/plolcott/x86utm/blob/master/Halt7.c
The above code proves that HHH does simulate itself
simulating DD.
That you can't understand this code proves that you lack the >>>>>>>>>>> technical basis to review my work.
It turns out that Olcott does not even understand this simple >>>>>>>>>> proof that HHH produces false negatives. HHH is unable to
simulate itself up to the normal termination.
If you try to explain your view in terms of a line-by-line
execution trace of DD simulated by HHH everyone will see that >>>>>>>>> your claim has no actual basis what-so-ever and is merely
utterly baseless rhetoric totally bereft of any supporting
reasoning.
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>> tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly
simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself correctly. >>>>>
is incorrect.
It is true as a verified fact and has been pointed out to Olcott
many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
It is a verified fact that the input to HHH(main) cannot
possibly terminate normally.
No, the verified fact is that the input can terminatie normally
The directly executed main IS NOT THE INPUT TO HHH.
On 2/10/2025 6:52 AM, joes wrote:RSVP
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according to
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct value
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
If this was true then you could point out exactly where HHH isIndeed, which proves that HHH is unable to simulate itselfIt is a verified fact that main cannot possibly be correctlySo, in other words, Olcott denies verified facts.simulate itself up to the normal termination.The execution trace only shows that HHH is unable to complete >>>>>>>>>>>> its simulation, because HHH is unable to simulate itself. >>>>>>>>>> It turns out that Olcott does not even understand this simple >>>>>>>>>> proof that HHH produces false negatives. HHH is unable toWhich proves that HHH fails to make a correct decision >>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>> execution,
simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>>>> programmed when it aborts one cycle before the simulation >>>>>>>>>>>>>> would end normally.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>> tries to hide with a lot of irrelevant words.
simulated by HHH until its normal termination.
correctly.
incorrect.
value.
as soon as it correctly determines that its input cannot possibly
terminate normally.
spec, so does the inner, because it is the same. Therefore it can’t
report „non-halting” and be correct. If the inner HHH doesn’t halt, it >> is not a decider.
You didn’t look at it.That is not an error.Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
It is a verified fact that DD correctly simulated by HHH cannot possibly terminate normally. The line you referred to does not change that
verified fact.
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct value
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote:
On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
incorrect.Indeed, which proves that HHH is unable to simulate itself correctly. >>>>> If this was true then you could point out exactly where HHH isIt is a verified fact that main cannot possibly be correctlySo, in other words, Olcott denies verified facts.simulate itself up to the normal termination.The execution trace only shows that HHH is unable to complete >>>>>>>>>>>> its simulation, because HHH is unable to simulate itself. >>>>>>>>>> It turns out that Olcott does not even understand this simple >>>>>>>>>> proof that HHH produces false negatives. HHH is unable toWhich proves that HHH fails to make a correct decision about >>>>>>>>>>>>>> DD's halting behaviour. All other methods (direct execution, >>>>>>>>>>>>>> simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>>>> programmed when it aborts one cycle before the simulation >>>>>>>>>>>>>> would end normally.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>> tries to hide with a lot of irrelevant words.
simulated by HHH until its normal termination.
value.
as soon as it correctly determines that its input cannot possibly
terminate normally.
to spec, so does the inner, because it is the same. Therefore
it can’t report „non-halting” and be correct. If the inner HHH
doesn’t halt, it is not a decider.
Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
That is not an error.
It is a verified fact that DD correctly simulated by HHH cannot
possibly terminate normally. The line you referred to does not
change that verified fact.
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:RSVP
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according to
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct value >>>>> as soon as it correctly determines that its input cannot possibly
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
If this was true then you could point out exactly where HHH isIndeed, which proves that HHH is unable to simulate itselfIt is a verified fact that main cannot possibly be correctly >>>>>>>>> simulated by HHH until its normal termination.So, in other words, Olcott denies verified facts.The execution trace only shows that HHH is unable to complete >>>>>>>>>>>>>> its simulation, because HHH is unable to simulate itself. >>>>>>>>>>>> It turns out that Olcott does not even understand this simple >>>>>>>>>>>> proof that HHH produces false negatives. HHH is unable to >>>>>>>>>>>> simulate itself up to the normal termination.Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>>>> execution,
simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>>>>>> understanding of programming sees that HHH is not correctly >>>>>>>>>>>>>>>> programmed when it aborts one cycle before the simulation >>>>>>>>>>>>>>>> would end normally.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>> tries to hide with a lot of irrelevant words.
correctly.
incorrect.
value.
terminate normally.
spec, so does the inner, because it is the same. Therefore it can’t
report „non-halting” and be correct. If the inner HHH doesn’t halt, it
is not a decider.
That is not an error.Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
It is a verified fact that DD correctly simulated by HHH cannot possibly >>> terminate normally. The line you referred to does not change that
verified fact.
You didn’t look at it.
I did look at it and was pleased that you noticed the significance
of this line-of-code. None-the-less it does not and cannot possibly
alter the truism that DD simulated by HHH cannot possibly terminate
normally.
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:The input to HHH, which is main(), terminates. HHH does not simulate that.
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
This main is a program that includes all functions called directly andThe directly executed main IS NOT THE INPUT TO HHH.No, the verified fact is that the input can terminatie normallyIt is a verified fact that the input to HHH(main) cannot possiblyIt is true as a verified fact and has been pointed out to OlcottIf this was true then you could point out exactly where HHH isIndeed, which proves that HHH is unable to simulate itselfSo, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>> tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>> simulated by HHH until its normal termination.
correctly.
incorrect.
many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
terminate normally.
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH cannot possibly terminate normally.
The directly executed main() *IS NOT* the input to HHH(main)Do you not think you can pass a program to a simulator? What else do
and *IS NOT* simulated by HHH.
The security guard at the front door cannot even see the back door thusThe guard should damn well be.
is not accountable for the back door.
HHH can see what its input does and that *IS ALL* that it is accountableNo. HHH can see what itself does. If it did something different to the
for.
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:If you try to explain your view in terms of a line-by-line >>>>>>>>>>> execution trace of DD simulated by HHH everyone will see that >>>>>>>>>>> your claim has no actual basis what-so-ever and is merely >>>>>>>>>>> utterly baseless rhetoric totally bereft of any supporting >>>>>>>>>>> reasoning.
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:The execution trace only shows that HHH is unable to >>>>>>>>>>>>>> complete its simulation, because HHH is unable to simulate >>>>>>>>>>>>>> itself.
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically last >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> very long and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be immediately followed by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> riskier fourth line >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of treatment that has an initial >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> success rate much higher >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved ! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The halting problem proof input does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify non- halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to its decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming >>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
sufficiently well (thus not confused by the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> unreachable
"if" statement) correctly understands that >>>>>>>>>>>>>>>>>>>>>>>>>>>>> DD simulated
by HHH cannot possibly reach its own return >>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction.
And anyone that understand the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem knows that isn't the question being >>>>>>>>>>>>>>>>>>>>>>>>>>>> asked. The quesiton you NEED to ask is will >>>>>>>>>>>>>>>>>>>>>>>>>>>> the program described by the input halt when >>>>>>>>>>>>>>>>>>>>>>>>>>>> run?
Since you start off with the wrong question, >>>>>>>>>>>>>>>>>>>>>>>>>>>> you logic is just faulty. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Everyone that thinks my question is incorrect >>>>>>>>>>>>>>>>>>>>>>>>>>> is wrong.
It has always been a mathematical mapping >>>>>>>>>>>>>>>>>>>>>>>>>>> from finite
strings to behaviors. That people do not >>>>>>>>>>>>>>>>>>>>>>>>>>> comprehend this
shows the shallowness of the depth of the >>>>>>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
(lack of) understanding. >>>>>>>>>>>>>>>>>>>>>>>>>>>
No, you are just incorreect as you don't know >>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about. >>>>>>>>>>>>>>>>>>>>>>>>>>
Yes, it is a mapping of the string to the >>>>>>>>>>>>>>>>>>>>>>>>>> behavior, and that mapping is DEFINED to be >>>>>>>>>>>>>>>>>>>>>>>>>> the halting behavior of the program the string >>>>>>>>>>>>>>>>>>>>>>>>>> describes.
No this is incorrect. The input finite string >>>>>>>>>>>>>>>>>>>>>>>>> specifies
(not merely describes) non halting behavior to >>>>>>>>>>>>>>>>>>>>>>>>> its decider.
No, since the definition of "Halting Behavior" >>>>>>>>>>>>>>>>>>>>>>>> is the behavior of the progran being run. >>>>>>>>>>>>>>>>>>>>>>>>
It may seem that way to people that have learned- >>>>>>>>>>>>>>>>>>>>>>> by- rote
as their only basis. It is actually nothing like >>>>>>>>>>>>>>>>>>>>>>> that.
No, that *IS* the definition.
A termination analyzer computes the mapping from >>>>>>>>>>>>>>>>>>>>> finite
strings to the actual behavior that these finite >>>>>>>>>>>>>>>>>>>>> strings
specify. That this is not dead obvious to everyone >>>>>>>>>>>>>>>>>>>>> here
merely proves that learned-by-rote does not involve >>>>>>>>>>>>>>>>>>>>> any
actual comprehension.
And the behavior the finite string specifies is the >>>>>>>>>>>>>>>>>>>> behavior of running the program.
That is verifiably factually incorrect.
The running program has a different execution trace >>>>>>>>>>>>>>>>>>> than the behavior that DD specifies to HHH. >>>>>>>>>>>>>>>>>>>
If so, then it proves the failure of the simulation. >>>>>>>>>>>>>>>>>> The simulation aborts too soon on unsound grounds, one >>>>>>>>>>>>>>>>>> cycle before the normal termination of the program. >>>>>>>>>>>>>>>>>>
This proves that you simply don't have sufficient >>>>>>>>>>>>>>>>> understanding of the C programming language. >>>>>>>>>>>>>>>>> DD simulated by HHH cannot possibly terminate normally >>>>>>>>>>>>>>>>> is a verified fact.
Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>>>> execution, simulation by a world class simulator, etc.) >>>>>>>>>>>>>>>> show that DD halts. But HHH fails to see it. Everyone >>>>>>>>>>>>>>>> with sufficient understanding of programming sees that >>>>>>>>>>>>>>>> HHH is not correctly programmed when it aborts one cycle >>>>>>>>>>>>>>>> before the simulation would end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace
of HHH simulating DD calling HHH(DD) simulating DD... >>>>>>>>>>>>>>
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>> The above code proves that HHH does simulate itself
simulating DD.
That you can't understand this code proves that you lack the >>>>>>>>>>>>> technical basis to review my work.
It turns out that Olcott does not even understand this >>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>> tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>> simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself
correctly.
If this was true then you could point out exactly where HHH
is incorrect.
It is true as a verified fact and has been pointed out to Olcott
many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
It is a verified fact that the input to HHH(main) cannot
possibly terminate normally.
No, the verified fact is that the input can terminatie normally
The directly executed main IS NOT THE INPUT TO HHH.
This main is a program that includes all functions called directly and
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH
cannot possibly terminate normally.
The directly executed main() *IS NOT* the input to HHH(main)
and *IS NOT* simulated by HHH.
The security guard at the front door cannot even see
the back door thus is not accountable for the back door.
HHH can see what its input does and that *IS ALL* that
it is accountable for.
On 2/10/2025 2:48 PM, joes wrote:Hello?
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:RSVP
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according to
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote:
Op 08.feb.2025 om 06:53 schreef olcott:
On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
If this was true then you could point out exactly where HHH isIndeed, which proves that HHH is unable to simulate itselfIt is a verified fact that main cannot possibly be correctly >>>>>>>>> simulated by HHH until its normal termination.So, in other words, Olcott denies verified facts.It turns out that Olcott does not even understand this simple >>>>>>>>>>>> proof that HHH produces false negatives. HHH is unable to >>>>>>>>>>>> simulate itself up to the normal termination.The execution trace only shows that HHH is unable to >>>>>>>>>>>>>> complete its simulation, because HHH is unable to simulate >>>>>>>>>>>>>> itself.Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>>>> execution,
simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>>>>>> understanding of programming sees that HHH is not >>>>>>>>>>>>>>>> correctly programmed when it aborts one cycle before the >>>>>>>>>>>>>>>> simulation would end normally.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>> tries to hide with a lot of irrelevant words.
correctly.
incorrect.
value.
value as soon as it correctly determines that its input cannot
possibly terminate normally.
spec, so does the inner, because it is the same. Therefore it can’t
report „non-halting” and be correct. If the inner HHH doesn’t halt, >>>> it is not a decider.
The significance of that line is that it changes the halting behaviourI did look at it and was pleased that you noticed the significance ofYou didn’t look at it.That is not an error.Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
It is a verified fact that DD correctly simulated by HHH cannot
possibly terminate normally. The line you referred to does not change
that verified fact.
this line-of-code. None-the-less it does not and cannot possibly alter
the truism that DD simulated by HHH cannot possibly terminate normally.
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
This main is a program that includes all functions called directly and >>>> indirectly, including HHH.The directly executed main IS NOT THE INPUT TO HHH.No, the verified fact is that the input can terminatie normallyIt is a verified fact that the input to HHH(main) cannot possibly >>>>>>> terminate normally.It is true as a verified fact and has been pointed out to Olcott >>>>>>>> many times, but he refuses to learn. So, again:If this was true then you could point out exactly where HHH is >>>>>>>>> incorrect.Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>> correctly.So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>>>> tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>> simulated by HHH until its normal termination.
It is a verified fact that main halts,
The input to HHH(main) when correctly simulated by HHH cannot possibly
terminate normally.
The input to HHH, which is main(), terminates. HHH does not simulate
that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
Unless HHH does abort the simulation of its input HHHIf the simulating HHH would not abort, then the simulated HHH would
itself would never terminate normally. This by itself
proves that that the input to HHH cannot possibly
terminate normally.
On 2/11/2025 4:07 AM, Fred. Zwarts wrote:Why does Olcott keep denying verified facts? The finite string has been
Op 10.feb.2025 om 21:36 schreef olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:If you try to explain your view in terms of a line-by-line >>>>>>>>>>>>> execution trace of DD simulated by HHH everyone will see that >>>>>>>>>>>>> your claim has no actual basis what-so-ever and is merely >>>>>>>>>>>>> utterly baseless rhetoric totally bereft of any supporting >>>>>>>>>>>>> reasoning.
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>> simulate itself.
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
That is verifiably factually incorrect. >>>>>>>>>>>>>>>>>>>>> The running program has a different execution trace >>>>>>>>>>>>>>>>>>>>> than the behavior that DD specifies to HHH. >>>>>>>>>>>>>>>>>>>>>On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> last very long and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be immediately followed by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> riskier fourth line >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of treatment that has an initial >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> success rate much higher >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved ! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The halting problem proof input does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify non- halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to its decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
sufficiently well (thus not confused by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the unreachable
"if" statement) correctly understands >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by HHH cannot possibly reach its own >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return instruction. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
And anyone that understand the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem knows that isn't the question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being asked. The quesiton you NEED to ask >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is will the program described by the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt when run?
Since you start off with the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question, you logic is just faulty. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Everyone that thinks my question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect is wrong.
It has always been a mathematical mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>> from finite
strings to behaviors. That people do not >>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehend this
shows the shallowness of the depth of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
(lack of) understanding. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, you are just incorreect as you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>> know what you are talking about. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Yes, it is a mapping of the string to the >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior, and that mapping is DEFINED to be >>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting behavior of the program the >>>>>>>>>>>>>>>>>>>>>>>>>>>> string describes.
No this is incorrect. The input finite string >>>>>>>>>>>>>>>>>>>>>>>>>>> specifies
(not merely describes) non halting behavior >>>>>>>>>>>>>>>>>>>>>>>>>>> to its decider.
No, since the definition of "Halting Behavior" >>>>>>>>>>>>>>>>>>>>>>>>>> is the behavior of the progran being run. >>>>>>>>>>>>>>>>>>>>>>>>>>
It may seem that way to people that have >>>>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
as their only basis. It is actually nothing >>>>>>>>>>>>>>>>>>>>>>>>> like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from >>>>>>>>>>>>>>>>>>>>>>> finite
strings to the actual behavior that these finite >>>>>>>>>>>>>>>>>>>>>>> strings
specify. That this is not dead obvious to >>>>>>>>>>>>>>>>>>>>>>> everyone here
merely proves that learned-by-rote does not >>>>>>>>>>>>>>>>>>>>>>> involve any
actual comprehension.
And the behavior the finite string specifies is >>>>>>>>>>>>>>>>>>>>>> the behavior of running the program. >>>>>>>>>>>>>>>>>>>>>
If so, then it proves the failure of the simulation. >>>>>>>>>>>>>>>>>>>> The simulation aborts too soon on unsound grounds, >>>>>>>>>>>>>>>>>>>> one cycle before the normal termination of the program. >>>>>>>>>>>>>>>>>>>>
This proves that you simply don't have sufficient >>>>>>>>>>>>>>>>>>> understanding of the C programming language. >>>>>>>>>>>>>>>>>>> DD simulated by HHH cannot possibly terminate normally >>>>>>>>>>>>>>>>>>> is a verified fact.
Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods >>>>>>>>>>>>>>>>>> (direct execution, simulation by a world class >>>>>>>>>>>>>>>>>> simulator, etc.) show that DD halts. But HHH fails to >>>>>>>>>>>>>>>>>> see it. Everyone with sufficient understanding of >>>>>>>>>>>>>>>>>> programming sees that HHH is not correctly programmed >>>>>>>>>>>>>>>>>> when it aborts one cycle before the simulation would >>>>>>>>>>>>>>>>>> end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace >>>>>>>>>>>>>>>>> of HHH simulating DD calling HHH(DD) simulating DD... >>>>>>>>>>>>>>>>
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>> The above code proves that HHH does simulate itself >>>>>>>>>>>>>>> simulating DD.
That you can't understand this code proves that you lack the >>>>>>>>>>>>>>> technical basis to review my work.
It turns out that Olcott does not even understand this >>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>> he tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>> simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>> correctly.
If this was true then you could point out exactly where HHH
is incorrect.
It is true as a verified fact and has been pointed out to Olcott >>>>>>>> many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
It is a verified fact that the input to HHH(main) cannot
possibly terminate normally.
No, the verified fact is that the input can terminatie normally
The directly executed main IS NOT THE INPUT TO HHH.
This main is a program that includes all functions called directly
and indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH
cannot possibly terminate normally.
Which proves that HHH fails, because the direct execution and many
other simulators do execute it up to normal termination.
This makes it a verified fact that HHH fails.
The code itself conclusively proves that I and the code are
both correct. That you disagree with this code is ridiculous.
That you can come up with an example that is more difficult
for you to understand is not useful.
DD simulated by HHH cannot possibly terminate normally. https://www.researchgate.net/ publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:This main is a program that includes all functions called directly >>>>>> and
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:No, the verified fact is that the input can terminatie normally >>>>>>> The directly executed main IS NOT THE INPUT TO HHH.
Op 09.feb.2025 om 20:54 schreef olcott:It is a verified fact that the input to HHH(main) cannot possibly >>>>>>>>> terminate normally.
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:It is true as a verified fact and has been pointed out to Olcott >>>>>>>>>> many times, but he refuses to learn. So, again:
Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where HHH is >>>>>>>>>>> incorrect.
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>> correctly.
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:So, in other words, Olcott denies verified facts.
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 04:38 schrieb olcott: >>>>
HHH generates false negatives, as is verified in
int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>> which he
tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>> simulated by HHH until its normal termination.
It is a verified fact that main halts,
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH cannot possibly >>>>> terminate normally.
The input to HHH, which is main(), terminates. HHH does not simulate
that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort.
That cannot possibly work. The executed HHH always sees at least one
more full execution trace than any inner HHH ever sees.
On 2/11/2025 9:23 AM, joes wrote:Oh goody, you’re never getting anywhere if you reject corrections.
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:I am not going to ever talk about that.
On 2/10/2025 2:48 PM, joes wrote:Hello?
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:RSVP
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according to >>>>>> spec, so does the inner, because it is the same. Therefore it can’t >>>>>> report „non-halting” and be correct. If the inner HHH doesn’t halt,
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct >>>>>>> value as soon as it correctly determines that its input cannot
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct >>>>>>>> value.
Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where HHH is >>>>>>>>> incorrect.
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>> correctly.
Op 09.feb.2025 om 18:00 schreef olcott:It is a verified fact that main cannot possibly be correctly >>>>>>>>>>> simulated by HHH until its normal termination.
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:HHH generates false negatives, as is verified in
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:It turns out that Olcott does not even understand this >>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>> So, in other words, Olcott denies verified facts.
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>> simulate itself.
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>>>>>> execution,
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>
simulation by a world class simulator, etc.) show that >>>>>>>>>>>>>>>>>> DD halts. But HHH fails to see it. Everyone with >>>>>>>>>>>>>>>>>> sufficient understanding of programming sees that HHH >>>>>>>>>>>>>>>>>> is not correctly programmed when it aborts one cycle >>>>>>>>>>>>>>>>>> before the simulation would end normally.
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>> he tries to hide with a lot of irrelevant words.
possibly terminate normally.
it is not a decider.
Sure. If you changed that line, it could.So you have a very hard time staying laser focused on the actual exactThe significance of that line is that it changes the halting behaviourI did look at it and was pleased that you noticed the significance ofYou didn’t look at it.That is not an error.Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
It is a verified fact that DD correctly simulated by HHH cannot
possibly terminate normally. The line you referred to does not
change that verified fact.
this line-of-code. None-the-less it does not and cannot possibly alter
the truism that DD simulated by HHH cannot possibly terminate
normally.
of HHH.
point that this line-of-code:
HAS ABSOLUTELY NOTHING TO DO WITH THE FACT THAT DD SIMULATED BY HHH
CANNOT POSSIBLY TERMINATE NORMALLY.
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott:
This main is a program that includes all functions called directly and >>>> indirectly, including HHH.The directly executed main IS NOT THE INPUT TO HHH.No, the verified fact is that the input can terminatie normallyIt is a verified fact that the input to HHH(main) cannot possibly >>>>>>> terminate normally.It is true as a verified fact and has been pointed out to Olcott >>>>>>>> many times, but he refuses to learn. So, again:If this was true then you could point out exactly where HHH is >>>>>>>>> incorrect.Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>> correctly.So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>>>> tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>> simulated by HHH until its normal termination.
It is a verified fact that main halts,
The input to HHH(main) when correctly simulated by HHH cannot possibly
terminate normally.
The input to HHH, which is main(), terminates. HHH does not simulate
that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
Unless HHH does abort the simulation of its input HHH
itself would never terminate normally. This by itself
proves that that the input to HHH cannot possibly
terminate normally.
The directly executed main() *IS NOT* the input to HHH(main)Do you not think you can pass a program to a simulator? What else do
and *IS NOT* simulated by HHH.
you think HHH is simulating.
The security guard at the front door cannot even see the back door thusThe guard should damn well be.
is not accountable for the back door.
HHH can see what its input does and that *IS ALL* that it is accountable >>> for.No. HHH can see what itself does. If it did something different to the
input, that would not change what the input does.
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:This main is a program that includes all functions called directly >>>>>> and
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:No, the verified fact is that the input can terminatie normally >>>>>>> The directly executed main IS NOT THE INPUT TO HHH.
Op 09.feb.2025 om 20:54 schreef olcott:It is a verified fact that the input to HHH(main) cannot possibly >>>>>>>>> terminate normally.
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:It is true as a verified fact and has been pointed out to Olcott >>>>>>>>>> many times, but he refuses to learn. So, again:
Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where HHH is >>>>>>>>>>> incorrect.
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>> correctly.
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:So, in other words, Olcott denies verified facts.
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 04:38 schrieb olcott: >>>>
HHH generates false negatives, as is verified in
int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>> which he
tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>> simulated by HHH until its normal termination.
It is a verified fact that main halts,
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH cannot possibly >>>>> terminate normally.
The input to HHH, which is main(), terminates. HHH does not simulate
that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort.
That cannot possibly work. The executed HHH always sees at least one
more full execution trace than any inner HHH ever sees.
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:Hello?
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:RSVP
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according to >>>>>> spec, so does the inner, because it is the same. Therefore it can’t >>>>>> report „non-halting” and be correct. If the inner HHH doesn’t halt,
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct >>>>>>> value as soon as it correctly determines that its input cannot
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct >>>>>>>> value.
Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where HHH is >>>>>>>>> incorrect.
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>> correctly.
Op 09.feb.2025 om 18:00 schreef olcott:It is a verified fact that main cannot possibly be correctly >>>>>>>>>>> simulated by HHH until its normal termination.
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:So, in other words, Olcott denies verified facts.
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:It turns out that Olcott does not even understand this simple >>>>>>>>>>>>>> proof that HHH produces false negatives. HHH is unable to >>>>>>>>>>>>>> simulate itself up to the normal termination.
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to simulate >>>>>>>>>>>>>>>> itself.
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>>>>>> execution,
On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>
simulation by a world class simulator, etc.) show that DD >>>>>>>>>>>>>>>>>> halts. But HHH fails to see it. Everyone with sufficient >>>>>>>>>>>>>>>>>> understanding of programming sees that HHH is not >>>>>>>>>>>>>>>>>> correctly programmed when it aborts one cycle before the >>>>>>>>>>>>>>>>>> simulation would end normally.
HHH generates false negatives, as is verified in
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which he >>>>>>>>>>>> tries to hide with a lot of irrelevant words.
possibly terminate normally.
it is not a decider.
I am not going to ever talk about that.
I did look at it and was pleased that you noticed the significance ofYou didn’t look at it.That is not an error.Look at it.Here is the code point out the (nonexistent) error:https://github.com/plolcott/x86utm/blob/master/Halt7.c#L502
It is a verified fact that DD correctly simulated by HHH cannot
possibly terminate normally. The line you referred to does not change >>>>> that verified fact.
this line-of-code. None-the-less it does not and cannot possibly alter
the truism that DD simulated by HHH cannot possibly terminate normally.
The significance of that line is that it changes the halting behaviour
of HHH.
So you have a very hard time staying laser focused
on the actual exact point that this line-of-code:
HAS ABSOLUTELY NOTHING TO DO WITH THE FACT THAT DD
SIMULATED BY HHH CANNOT POSSIBLY TERMINATE NORMALLY.
On 2/11/2025 4:07 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 21:36 schreef olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:If you try to explain your view in terms of a line-by-line >>>>>>>>>>>>> execution trace of DD simulated by HHH everyone will see that >>>>>>>>>>>>> your claim has no actual basis what-so-ever and is merely >>>>>>>>>>>>> utterly baseless rhetoric totally bereft of any supporting >>>>>>>>>>>>> reasoning.
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote:The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>> simulate itself.
Op 08.feb.2025 om 15:47 schreef olcott:
On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote:
That is verifiably factually incorrect. >>>>>>>>>>>>>>>>>>>>> The running program has a different execution trace >>>>>>>>>>>>>>>>>>>>> than the behavior that DD specifies to HHH. >>>>>>>>>>>>>>>>>>>>>On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This treatment does not typically >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> last very long and >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will be immediately followed by a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> riskier fourth line >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of treatment that has an initial >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> success rate much higher >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than its non progression mortality rate. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Halting problem solved ! >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
The halting problem proof input does >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify non- halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior to its decider. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
https://www.researchgate.net/ >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
LOOOOOOOOL
Anyone that understands the C programming >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language
sufficiently well (thus not confused by >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the unreachable
"if" statement) correctly understands >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD simulated >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by HHH cannot possibly reach its own >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return instruction. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
And anyone that understand the halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem knows that isn't the question >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being asked. The quesiton you NEED to ask >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is will the program described by the input >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt when run?
Since you start off with the wrong >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question, you logic is just faulty. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Everyone that thinks my question is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect is wrong.
It has always been a mathematical mapping >>>>>>>>>>>>>>>>>>>>>>>>>>>>> from finite
strings to behaviors. That people do not >>>>>>>>>>>>>>>>>>>>>>>>>>>>> comprehend this
shows the shallowness of the depth of the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
(lack of) understanding. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
No, you are just incorreect as you don't >>>>>>>>>>>>>>>>>>>>>>>>>>>> know what you are talking about. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Yes, it is a mapping of the string to the >>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior, and that mapping is DEFINED to be >>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting behavior of the program the >>>>>>>>>>>>>>>>>>>>>>>>>>>> string describes.
No this is incorrect. The input finite string >>>>>>>>>>>>>>>>>>>>>>>>>>> specifies
(not merely describes) non halting behavior >>>>>>>>>>>>>>>>>>>>>>>>>>> to its decider.
No, since the definition of "Halting Behavior" >>>>>>>>>>>>>>>>>>>>>>>>>> is the behavior of the progran being run. >>>>>>>>>>>>>>>>>>>>>>>>>>
It may seem that way to people that have >>>>>>>>>>>>>>>>>>>>>>>>> learned- by- rote
as their only basis. It is actually nothing >>>>>>>>>>>>>>>>>>>>>>>>> like that.
No, that *IS* the definition.
A termination analyzer computes the mapping from >>>>>>>>>>>>>>>>>>>>>>> finite
strings to the actual behavior that these finite >>>>>>>>>>>>>>>>>>>>>>> strings
specify. That this is not dead obvious to >>>>>>>>>>>>>>>>>>>>>>> everyone here
merely proves that learned-by-rote does not >>>>>>>>>>>>>>>>>>>>>>> involve any
actual comprehension.
And the behavior the finite string specifies is >>>>>>>>>>>>>>>>>>>>>> the behavior of running the program. >>>>>>>>>>>>>>>>>>>>>
If so, then it proves the failure of the simulation. >>>>>>>>>>>>>>>>>>>> The simulation aborts too soon on unsound grounds, >>>>>>>>>>>>>>>>>>>> one cycle before the normal termination of the program. >>>>>>>>>>>>>>>>>>>>
This proves that you simply don't have sufficient >>>>>>>>>>>>>>>>>>> understanding of the C programming language. >>>>>>>>>>>>>>>>>>> DD simulated by HHH cannot possibly terminate normally >>>>>>>>>>>>>>>>>>> is a verified fact.
Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods >>>>>>>>>>>>>>>>>> (direct execution, simulation by a world class >>>>>>>>>>>>>>>>>> simulator, etc.) show that DD halts. But HHH fails to >>>>>>>>>>>>>>>>>> see it. Everyone with sufficient understanding of >>>>>>>>>>>>>>>>>> programming sees that HHH is not correctly programmed >>>>>>>>>>>>>>>>>> when it aborts one cycle before the simulation would >>>>>>>>>>>>>>>>>> end normally.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
You lack the ability to do the execution trace >>>>>>>>>>>>>>>>> of HHH simulating DD calling HHH(DD) simulating DD... >>>>>>>>>>>>>>>>
https://github.com/plolcott/x86utm/blob/master/Halt7.c >>>>>>>>>>>>>>> The above code proves that HHH does simulate itself >>>>>>>>>>>>>>> simulating DD.
That you can't understand this code proves that you lack the >>>>>>>>>>>>>>> technical basis to review my work.
It turns out that Olcott does not even understand this >>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>
So, in other words, Olcott denies verified facts.
HHH generates false negatives, as is verified in
int main() { return HHH(main); >>>>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>> he tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>> simulated by HHH until its normal termination.
Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>> correctly.
If this was true then you could point out exactly where HHH
is incorrect.
It is true as a verified fact and has been pointed out to Olcott >>>>>>>> many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
It is a verified fact that the input to HHH(main) cannot
possibly terminate normally.
No, the verified fact is that the input can terminatie normally
The directly executed main IS NOT THE INPUT TO HHH.
This main is a program that includes all functions called directly
and indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH
cannot possibly terminate normally.
Which proves that HHH fails, because the direct execution and many
other simulators do execute it up to normal termination.
This makes it a verified fact that HHH fails.
The code itself conclusively proves that I and the code are
both correct. That you disagree with this code is ridiculous.
That you can come up with an example that is more difficult
for you to understand is not useful.
DD simulated by HHH cannot possibly terminate normally. https://www.researchgate.net/ publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero
I reject infinite deflection away from the point. The absoluteOh goody, you’re never getting anywhere if you reject corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts according >>>>>>>> to spec, so does the inner, because it is the same. Therefore it >>>>>>>> can’t report „non-halting” and be correct. If the inner HHH >>>>>>>> doesn’t halt, it is not a decider.The directly executed HHH(DD) always halts and returns a correct >>>>>>>>> value as soon as it correctly determines that its input cannot >>>>>>>>> possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return theIf this was true then you could point out exactly where HHH is >>>>>>>>>>> incorrect.Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>> correctly.It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>> simulated by HHH until its normal termination.HHH generates false negatives, as is verified inIt turns out that Olcott does not even understand this >>>>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>> So, in other words, Olcott denies verified facts.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>> methods (direct execution,
simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone with >>>>>>>>>>>>>>>>>>>> sufficient understanding of programming sees that HHH >>>>>>>>>>>>>>>>>>>> is not correctly programmed when it aborts one cycle >>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>> simulate itself.
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>>>> he tries to hide with a lot of irrelevant words.
correct value.
single-mined focus point is that DD correctly simulated by HHH cannot possible terminate normally.
Since there is a 5% chance that the treatment I will have next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will totally
ignore anything that diverges from the point.
On 2/11/2025 10:44 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 17:22 schreef olcott:
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
This main is a program that includes all functions calledNo, the verified fact is that the input can terminatie normally >>>>>>>>> The directly executed main IS NOT THE INPUT TO HHH.It is a verified fact that the input to HHH(main) cannot >>>>>>>>>>> possiblyIt is true as a verified fact and has been pointed out to >>>>>>>>>>>> OlcottIf this was true then you could point out exactly where HHH is >>>>>>>>>>>>> incorrect.Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>>>> correctly.So, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>> int main() { return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>> which he
tries to hide with a lot of irrelevant words.
It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>>>> simulated by HHH until its normal termination.
many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
terminate normally.
directly and
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH cannot
possibly
terminate normally.
The input to HHH, which is main(), terminates. HHH does not
simulate that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort.
That cannot possibly work. The executed HHH always sees at least one
more full execution trace than any inner HHH ever sees.
Indeed, that is what I said, but Olcott deleted it in the citation.
HHH cannot do what it should do. So, he proves the halting theorem.
If the sentence it false it does not become true in some greater
context.
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:Oh goody, you’re never getting anywhere if you reject corrections.
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:I am not going to ever talk about that.
On 2/10/2025 2:48 PM, joes wrote:Hello?
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:RSVP
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:We were talking about HHH(HHH). If the outer HHH halts according to >>>>>>>> spec, so does the inner, because it is the same. Therefore it can’t >>>>>>>> report „non-halting” and be correct. If the inner HHH doesn’t halt,
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:The directly executed HHH(DD) always halts and returns a correct >>>>>>>>> value as soon as it correctly determines that its input cannot >>>>>>>>> possibly terminate normally.
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:HHH is supposed to be a decider, i.e. halt and return the correct >>>>>>>>>> value.
Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where HHH is >>>>>>>>>>> incorrect.
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>> correctly.
Op 09.feb.2025 om 18:00 schreef olcott:It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>> simulated by HHH until its normal termination.
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:HHH generates false negatives, as is verified in
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote:It turns out that Olcott does not even understand this >>>>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>> So, in other words, Olcott denies verified facts.
Op 09.feb.2025 om 07:10 schreef olcott:
On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Which proves that HHH fails to make a correct decision >>>>>>>>>>>>>>>>>>>> about DD's halting behaviour. All other methods (direct >>>>>>>>>>>>>>>>>>>> execution,Am 05.02.2025 um 16:11 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
Am 05.02.2025 um 04:38 schrieb olcott: >>>>>>>>>>
simulation by a world class simulator, etc.) show that >>>>>>>>>>>>>>>>>>>> DD halts. But HHH fails to see it. Everyone with >>>>>>>>>>>>>>>>>>>> sufficient understanding of programming sees that HHH >>>>>>>>>>>>>>>>>>>> is not correctly programmed when it aborts one cycle >>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>> simulate itself.
int main() {
return HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>>>> he tries to hide with a lot of irrelevant words.
it is not a decider.
I reject infinite deflection away from the point.
The absolute single-mined focus point is that
DD correctly simulated by HHH cannot possible
terminate normally.
Since there is a 5% chance that the treatment I will
have next month will kill me and this treatment is
my only good chance I will totally ignore anything
that diverges from the point.
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero
I reject infinite deflection away from the point. The absoluteOh goody, you’re never getting anywhere if you reject corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts according >>>>>>>>>> to spec, so does the inner, because it is the same. Therefore it >>>>>>>>>> can’t report „non-halting” and be correct. If the inner HHH >>>>>>>>>> doesn’t halt, it is not a decider.The directly executed HHH(DD) always halts and returns a correct >>>>>>>>>>> value as soon as it correctly determines that its input cannot >>>>>>>>>>> possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>> correct value.If this was true then you could point out exactly where HHH is >>>>>>>>>>>>> incorrect.Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>>>> correctly.return HHH(main); >>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand this >>>>>>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>>>> So, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>> int main() {Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>> methods (direct execution,
simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone with >>>>>>>>>>>>>>>>>>>>>> sufficient understanding of programming sees that HHH >>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when it aborts one cycle >>>>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>>>> simulate itself.
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>>>>>> he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>>>> simulated by HHH until its normal termination.
single-mined focus point is that DD correctly simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will have next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate normally.
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 16:18 schreef olcott:
On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero
I reject infinite deflection away from the point. The absoluteOh goody, you’re never getting anywhere if you reject corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts according >>>>>>>>>> to spec, so does the inner, because it is the same. Therefore it >>>>>>>>>> can’t report „non-halting” and be correct. If the inner HHH >>>>>>>>>> doesn’t halt, it is not a decider.The directly executed HHH(DD) always halts and returns a correct >>>>>>>>>>> value as soon as it correctly determines that its input cannot >>>>>>>>>>> possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>> correct value.If this was true then you could point out exactly where HHH is >>>>>>>>>>>>> incorrect.Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>>>> correctly.return HHH(main); >>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand this >>>>>>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>>>> So, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>> int main() {Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>> methods (direct execution,
simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone with >>>>>>>>>>>>>>>>>>>>>> sufficient understanding of programming sees that HHH >>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when it aborts one cycle >>>>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>>>> simulate itself.
but he denies it.
He lacks the ability to accept simple verified facts, which >>>>>>>>>>>>>>>> he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be correctly >>>>>>>>>>>>>>> simulated by HHH until its normal termination.
single-mined focus point is that DD correctly simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will have next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate normally.
On 2/13/2025 4:53 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 05:12 schreef olcott:
On 2/11/2025 10:44 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 17:22 schreef olcott:
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
This main is a program that includes all functions calledNo, the verified fact is that the input can terminatie normally >>>>>>>>>>> The directly executed main IS NOT THE INPUT TO HHH.It is a verified fact that the input to HHH(main) cannot >>>>>>>>>>>>> possiblyIt is true as a verified fact and has been pointed out to >>>>>>>>>>>>>> OlcottIf this was true then you could point out exactly where >>>>>>>>>>>>>>> HHH isSo, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>> int main() { return HHH(main);It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>> correctly
}
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>> which he
tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>
simulated by HHH until its normal termination. >>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>>>>>> correctly.
incorrect.
many times, but he refuses to learn. So, again:
It is a verified fact that main halts,
terminate normally.
directly and
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH cannot >>>>>>>>> possibly
terminate normally.
The input to HHH, which is main(), terminates. HHH does not
simulate that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort.
That cannot possibly work. The executed HHH always sees at least one >>>>> more full execution trace than any inner HHH ever sees.
Indeed, that is what I said, but Olcott deleted it in the citation.
HHH cannot do what it should do. So, he proves the halting theorem.
If the sentence it false it does not become true in some greater
context.
Indeed and since it is false that the simulated HHH would not abort,
This is simply beyond your skill level.
Since each HHH is exactly the same unless the first
one aborts none of them do.
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:What is the non-input?
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
The correct simulation is only the one that it sees by definition. itAnyone that knows the C language sufficiently well knows that DDThat IS the point. DD does nothing else than call HHH.single-mined focus point is that DD correctly simulated by HHHOh goody, you’re never getting anywhere if you reject corrections. >>>>> I reject infinite deflection away from the point. The absoluteI am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>> according to spec, so does the inner, because it is the same. >>>>>>>>>>>> Therefore it can’t report „non-halting” and be correct. If >>>>>>>>>>>> the inner HHH doesn’t halt, it is not a decider.The directly executed HHH(DD) always halts and returns a >>>>>>>>>>>>> correct value as soon as it correctly determines that its >>>>>>>>>>>>> input cannot possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>> correct value.If this was true then you could point out exactly where >>>>>>>>>>>>>>> HHH is incorrect.So, in other words, Olcott denies verified facts. HHH >>>>>>>>>>>>>>>>>> generates false negatives, as is verified in >>>>>>>>>>>>>>>>>> int main() {It turns out that Olcott does not even understand >>>>>>>>>>>>>>>>>>>> this simple proof that HHH produces false negatives. >>>>>>>>>>>>>>>>>>>> HHH is unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>> termination.The execution trace only shows that HHH is unable >>>>>>>>>>>>>>>>>>>>>> to complete its simulation, because HHH is unable >>>>>>>>>>>>>>>>>>>>>> to simulate itself.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution,
simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone >>>>>>>>>>>>>>>>>>>>>>>> with sufficient understanding of programming sees >>>>>>>>>>>>>>>>>>>>>>>> that HHH is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>> normally.
return HHH(main); >>>>>>>>>>>>>>>>>> }
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>> which he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>> correctly simulated by HHH until its normal termination. >>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>> itself correctly.
cannot possible terminate normally.
Since there is a 5% chance that the treatment I will have next month >>>>> will kill me and this treatment is my only good chance I willOk, I will wait a month then.
totally ignore anything that diverges from the point.
correctly simulated by HHH cannot possibly terminate normally.
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non-input
have always been wrong.
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott:
On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 18:00 schreef olcott:
On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero
single-mined focus point is that DD correctly simulated by HHH cannot >>>>> possible terminate normally.Oh goody, you’re never getting anywhere if you reject corrections. >>>>> I reject infinite deflection away from the point. The absoluteI am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>> accordingThe directly executed HHH(DD) always halts and returns a >>>>>>>>>>>>> correctHHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>> correct value.If this was true then you could point out exactly where >>>>>>>>>>>>>>> HHH issimulated by HHH until its normal termination. >>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate itself >>>>>>>>>>>>>>>> correctly.return HHH(main); >>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand this >>>>>>>>>>>>>>>>>>>> simple proof that HHH produces false negatives. HHH is >>>>>>>>>>>>>>>>>>>> unable to simulate itself up to the normal termination. >>>>>>>>>>>>>>>>>> So, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>> int main() {Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution,
simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone >>>>>>>>>>>>>>>>>>>>>>>> with
sufficient understanding of programming sees >>>>>>>>>>>>>>>>>>>>>>>> that HHH
is not correctly programmed when it aborts one >>>>>>>>>>>>>>>>>>>>>>>> cycle
before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is unable to >>>>>>>>>>>>>>>>>>>>>> complete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>>>>>> simulate itself.
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>> which
he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>> correctly
incorrect.
value as soon as it correctly determines that its input cannot >>>>>>>>>>>>> possibly terminate normally.
to spec, so does the inner, because it is the same.
Therefore it
can’t report „non-halting” and be correct. If the inner HHH >>>>>>>>>>>> doesn’t halt, it is not a decider.
Since there is a 5% chance that the treatment I will have next month >>>>> will kill me and this treatment is my only good chance I will totally >>>>> ignore anything that diverges from the point.Ok, I will wait a month then.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate normally.
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior
of a non-input have always been wrong.
On 2/13/2025 9:15 PM, Richard Damon wrote:
On 2/13/25 7:09 PM, olcott wrote:
On 2/13/2025 4:53 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 05:12 schreef olcott:
On 2/11/2025 10:44 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 17:22 schreef olcott:
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
A program that is no longer being simulated DOES NOTHINGBut the first one DOES abort, as that is how it was defined to be.If the sentence it false it does not become true in some greaterIndeed, that is what I said, but Olcott deleted it in the citation. >>>>>> HHH cannot do what it should do. So, he proves the halting theorem. >>>>>The directly executed main() is not the same instance of main() >>>>>>>>> that is input to HHH and simulated by HHH.This main is a program that includes all functions called >>>>>>>>>>>> directly and indirectly, including HHH.The directly executed main IS NOT THE INPUT TO HHH.No, the verified fact is that the input can terminatie >>>>>>>>>>>>>> normallyIt is a verified fact that the input to HHH(main) cannot >>>>>>>>>>>>>>> possibly terminate normally.It is true as a verified fact and has been pointed out to >>>>>>>>>>>>>>>> Olcott many times, but he refuses to learn. So, again: >>>>>>>>>>>>>>>> It is a verified fact that main halts,If this was true then you could point out exactly where >>>>>>>>>>>>>>>>> HHH is incorrect.Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>> itself correctly.So, in other words, Olcott denies verified facts. HHH >>>>>>>>>>>>>>>>>>>> generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>> int main() { return >>>>>>>>>>>>>>>>>>>> HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>>>> which he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>> words.
It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>> correctly simulated by HHH until its normal >>>>>>>>>>>>>>>>>>> termination.
The input to HHH(main) when correctly simulated by HHH cannot >>>>>>>>>>> possibly terminate normally.
The input to HHH, which is main(), terminates. HHH does not >>>>>>>>>> simulate that.
The directly executed main() relies on HHH aborting the
simulation of its input. HHH cannot rely on anything else
aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort.
That cannot possibly work. The executed HHH always sees at least >>>>>>> one more full execution trace than any inner HHH ever sees.
context.
Indeed and since it is false that the simulated HHH would not abort,
This is simply beyond your skill level.
Since each HHH is exactly the same unless the first one aborts none of
them do.
And thus, the one that DD calls aborts.
On 2/14/2025 3:36 AM, joes wrote:Oh, but we’re not interested in the behaviour of HHH(HHH(DD)).
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 10:02 PM, olcott wrote:
What is the non-input?The correct simulation is only the one that it sees by definition. itAnyone that knows the C language sufficiently well knows that DDSince there is a 5% chance that the treatment I will have nextOk, I will wait a month then.
month will kill me and this treatment is my only good chance I
will totally ignore anything that diverges from the point.
correctly simulated by HHH cannot possibly terminate normally.
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non-input
have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
--The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
DD specifies halting behaviour, by only calling a „decider”, a program purported to halt.HHH(DD) maps the finite string input of DD to the behavior that itThe correct simulation is only the one that it sees by definition. itAnyone that knows the C language sufficiently well knows that DDSince there is a 5% chance that the treatment I will have nextOk, I will wait a month then.
month will kill me and this treatment is my only good chance I
will totally ignore anything that diverges from the point.
correctly simulated by HHH cannot possibly terminate normally.
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
If I close my eyes, so that I do not see the accident, I cannot claim
that the accident did not happen. That is the reasoning of a 2 years
old child.
Similarly, when HHH aborts the simulation, it closes its eyes for what
happens in a correct simulation of DD.
specifies.
This behavior does include DD repeatedly calling HHH(DD) inIf DD doesn’t halt, the outerHHH can’t be able to report on it;
recursive simulation that that cannot possibly terminate normally.
QFTAll of the people that think it should map the behavior of a non-inputIt is a verified fact that the finite string given to HHH describes a
have always been wrong.
program that halts.
But olcott claims he does not use this input, but a non-input, a
different program, as input to HHH. He does not understand that HHH
should decide about the input described by the finite string that has
been proven to halt.
On 2/13/2025 9:15 PM, Richard Damon wrote:
On 2/13/25 7:09 PM, olcott wrote:
On 2/13/2025 4:53 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 05:12 schreef olcott:
On 2/11/2025 10:44 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 17:22 schreef olcott:If the sentence it false it does not become true in some greater
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 16:11 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/5/2025 1:44 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am 05.02.2025 um 04:38 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
This main is a program that includes all functions called >>>>>>>>>>>> directly andThe directly executed main IS NOT THE INPUT TO HHH.No, the verified fact is that the input can terminatie >>>>>>>>>>>>>> normallyIt is a verified fact that the input to HHH(main) cannot >>>>>>>>>>>>>>> possiblyIt is true as a verified fact and has been pointed out >>>>>>>>>>>>>>>> to OlcottIf this was true then you could point out exactly where >>>>>>>>>>>>>>>>> HHH iscorrectly.So, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>> int main() { return HHH(main);It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>> correctly
}
but he denies it.
He lacks the ability to accept simple verified >>>>>>>>>>>>>>>>>>>> facts, which he
tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>>
simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>> itself
incorrect.
many times, but he refuses to learn. So, again: >>>>>>>>>>>>>>>> It is a verified fact that main halts,
terminate normally.
indirectly, including HHH.
The input to HHH(main) when correctly simulated by HHH cannot >>>>>>>>>>> possibly
terminate normally.
The input to HHH, which is main(), terminates. HHH does not >>>>>>>>>> simulate that.
The directly executed main() is not the same instance of
main() that is input to HHH and simulated by HHH.
The directly executed main() relies on HHH aborting
the simulation of its input. HHH cannot rely on anything
else aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort.
That cannot possibly work. The executed HHH always sees at least one >>>>>>> more full execution trace than any inner HHH ever sees.
Indeed, that is what I said, but Olcott deleted it in the citation. >>>>>> HHH cannot do what it should do. So, he proves the halting theorem. >>>>>
context.
Indeed and since it is false that the simulated HHH would not abort,
This is simply beyond your skill level.
Since each HHH is exactly the same unless the first
one aborts none of them do.
But the first one DOES abort, as that is how it was defined to be.
And thus, the one that DD calls aborts.
A program that is no longer being simulated DOES NOTHING
On 2/14/2025 3:36 AM, joes wrote:
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:What is the non-input?
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
The correct simulation is only the one that it sees by definition. itAnyone that knows the C language sufficiently well knows that DDThat IS the point. DD does nothing else than call HHH.single-mined focus point is that DD correctly simulated by HHHOh goody, you’re never getting anywhere if you reject corrections. >>>>>>> I reject infinite deflection away from the point. The absoluteI am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>> according to spec, so does the inner, because it is the same. >>>>>>>>>>>>>> Therefore it can’t report „non-halting” and be correct. If >>>>>>>>>>>>>> the inner HHH doesn’t halt, it is not a decider.The directly executed HHH(DD) always halts and returns a >>>>>>>>>>>>>>> correct value as soon as it correctly determines that its >>>>>>>>>>>>>>> input cannot possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>>>> correct value.If this was true then you could point out exactly where >>>>>>>>>>>>>>>>> HHH is incorrect.So, in other words, Olcott denies verified facts. HHH >>>>>>>>>>>>>>>>>>>> generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand >>>>>>>>>>>>>>>>>>>>>> this simple proof that HHH produces false negatives. >>>>>>>>>>>>>>>>>>>>>> HHH is unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>> termination.The execution trace only shows that HHH is unable >>>>>>>>>>>>>>>>>>>>>>>> to complete its simulation, because HHH is unable >>>>>>>>>>>>>>>>>>>>>>>> to simulate itself.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone >>>>>>>>>>>>>>>>>>>>>>>>>> with sufficient understanding of programming sees >>>>>>>>>>>>>>>>>>>>>>>>>> that HHH is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>> normally.
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>>>> which he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>> correctly simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>> itself correctly.
cannot possible terminate normally.
Since there is a 5% chance that the treatment I will have next month >>>>>>> will kill me and this treatment is my only good chance I willOk, I will wait a month then.
totally ignore anything that diverges from the point.
correctly simulated by HHH cannot possibly terminate normally.
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non-input
have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
On 2/14/2025 3:36 AM, joes wrote:
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:What is the non-input?
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:04 schreef olcott:
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
The correct simulation is only the one that it sees by definition. itAnyone that knows the C language sufficiently well knows that DDThat IS the point. DD does nothing else than call HHH.single-mined focus point is that DD correctly simulated by HHHOh goody, you’re never getting anywhere if you reject corrections. >>>>>>> I reject infinite deflection away from the point. The absoluteI am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>> according to spec, so does the inner, because it is the same. >>>>>>>>>>>>>> Therefore it can’t report „non-halting” and be correct. If >>>>>>>>>>>>>> the inner HHH doesn’t halt, it is not a decider.The directly executed HHH(DD) always halts and returns a >>>>>>>>>>>>>>> correct value as soon as it correctly determines that its >>>>>>>>>>>>>>> input cannot possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>>>> correct value.If this was true then you could point out exactly where >>>>>>>>>>>>>>>>> HHH is incorrect.So, in other words, Olcott denies verified facts. HHH >>>>>>>>>>>>>>>>>>>> generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand >>>>>>>>>>>>>>>>>>>>>> this simple proof that HHH produces false negatives. >>>>>>>>>>>>>>>>>>>>>> HHH is unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>> termination.The execution trace only shows that HHH is unable >>>>>>>>>>>>>>>>>>>>>>>> to complete its simulation, because HHH is unable >>>>>>>>>>>>>>>>>>>>>>>> to simulate itself.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. Everyone >>>>>>>>>>>>>>>>>>>>>>>>>> with sufficient understanding of programming sees >>>>>>>>>>>>>>>>>>>>>>>>>> that HHH is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>> normally.
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>>>> which he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>> correctly simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>> itself correctly.
cannot possible terminate normally.
Since there is a 5% chance that the treatment I will have next month >>>>>>> will kill me and this treatment is my only good chance I willOk, I will wait a month then.
totally ignore anything that diverges from the point.
correctly simulated by HHH cannot possibly terminate normally.
Indeed, which shows the limitation of HHH which makes that it cannot
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non-input
have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:Indeed, which shows the limitation of HHH which makes that it cannot
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:single-mined focus point is that DD correctly simulated by HHH
On 2/11/2025 9:23 AM, joes wrote:Oh goody, you’re never getting anywhere if you reject corrections. >>>>>>> I reject infinite deflection away from the point. The absolute
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:I am not going to ever talk about that.
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott:
On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>> accordingAm Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote:The directly executed HHH(DD) always halts and returns a >>>>>>>>>>>>>>> correct
HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>>>> correct value.Op 09.feb.2025 om 20:04 schreef olcott:If this was true then you could point out exactly where >>>>>>>>>>>>>>>>> HHH is
On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:correctly.
simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>> itselfSo, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand >>>>>>>>>>>>>>>>>>>>>> thiscomplete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>> simulate itself.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see it. >>>>>>>>>>>>>>>>>>>>>>>>>> Everyone withOn 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita Montero >>>>>>
sufficient understanding of programming sees >>>>>>>>>>>>>>>>>>>>>>>>>> that HHH
is not correctly programmed when it aborts one >>>>>>>>>>>>>>>>>>>>>>>>>> cycle
before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is >>>>>>>>>>>>>>>>>>>>>>>> unable to
simple proof that HHH produces false negatives. >>>>>>>>>>>>>>>>>>>>>> HHH is
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>> termination.
but he denies it.
He lacks the ability to accept simple verified >>>>>>>>>>>>>>>>>>>> facts, which
he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>> correctly
incorrect.
value as soon as it correctly determines that its input >>>>>>>>>>>>>>> cannot
possibly terminate normally.
to spec, so does the inner, because it is the same. >>>>>>>>>>>>>> Therefore it
can’t report „non-halting” and be correct. If the inner HHH
doesn’t halt, it is not a decider.
cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will have next month >>>>>>> will kill me and this treatment is my only good chance I willOk, I will wait a month then.
totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate normally. >>>>
properly decide about its input, because it must abort the correct
simulation before it sees that the correct simulation terminates
normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
If I close my eyes, so that I do not see the accident, I cannot claim
that the accident did not happen. That is the reasoning of a 2 years
old child.
HHH(DD) maps the finite string input of DD to the behavior that it
specifies. This behavior does include DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly terminate normally.
On 2/14/2025 6:58 AM, joes wrote:
Am Fri, 14 Feb 2025 06:42:29 -0600 schrieb olcott:
On 2/14/2025 3:36 AM, joes wrote:Oh, but we’re not interested in the behaviour of HHH(HHH(DD)).
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 10:02 PM, olcott wrote:
What is the non-input?The correct simulation is only the one that it sees by definition. it >>>>> maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.Anyone that knows the C language sufficiently well knows that DD >>>>>>> correctly simulated by HHH cannot possibly terminate normally.Since there is a 5% chance that the treatment I will have next >>>>>>>>> month will kill me and this treatment is my only good chance I >>>>>>>>> will totally ignore anything that diverges from the point.Ok, I will wait a month then.
Indeed, which shows the limitation of HHH which makes that it cannot >>>>>> properly decide about its input, because it must abort the correct >>>>>> simulation before it sees that the correct simulation terminates
normally.
All of the people that think it should map the behavior of a non-input >>>>> have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
DD correctly simulated by HHH cannot possibly terminate normally.
On 2/14/2025 6:53 AM, joes wrote:
Am Thu, 13 Feb 2025 22:20:32 -0600 schrieb olcott:
On 2/13/2025 9:15 PM, Richard Damon wrote:
On 2/13/25 7:09 PM, olcott wrote:
On 2/13/2025 4:53 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 05:12 schreef olcott:
On 2/11/2025 10:44 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 17:22 schreef olcott:
On 2/11/2025 10:10 AM, Fred. Zwarts wrote:
Op 11.feb.2025 om 15:38 schreef olcott:
On 2/11/2025 1:28 AM, joes wrote:
Am Mon, 10 Feb 2025 14:36:51 -0600 schrieb olcott:
On 2/10/2025 12:41 PM, Fred. Zwarts wrote:
Op 10.feb.2025 om 13:27 schreef olcott:
On 2/10/2025 6:14 AM, Fred. Zwarts wrote:
Op 10.feb.2025 om 12:51 schreef olcott:
On 2/10/2025 2:22 AM, Fred. Zwarts wrote:
Op 09.feb.2025 om 20:54 schreef olcott:
On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote:
A program that is no longer being simulated DOES NOTHINGBut the first one DOES abort, as that is how it was defined to be.This is simply beyond your skill level.If the sentence it false it does not become true in some greater >>>>>>> context.Indeed, that is what I said, but Olcott deleted it in the citation. >>>>>>>> HHH cannot do what it should do. So, he proves the halting theorem. >>>>>>>That cannot possibly work. The executed HHH always sees at least >>>>>>>>> one more full execution trace than any inner HHH ever sees.The directly executed main() is not the same instance of main() >>>>>>>>>>> that is input to HHH and simulated by HHH.This main is a program that includes all functions called >>>>>>>>>>>>>> directly and indirectly, including HHH.The directly executed main IS NOT THE INPUT TO HHH. >>>>>>>>>>>>>>>No, the verified fact is that the input can terminatie >>>>>>>>>>>>>>>> normallyIt is a verified fact that the input to HHH(main) cannot >>>>>>>>>>>>>>>>> possibly terminate normally.It is true as a verified fact and has been pointed out to >>>>>>>>>>>>>>>>>> Olcott many times, but he refuses to learn. So, again: >>>>>>>>>>>>>>>>>> It is a verified fact that main halts,If this was true then you could point out exactly where >>>>>>>>>>>>>>>>>>> HHH is incorrect.Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>>>> itself correctly.So, in other words, Olcott denies verified facts. HHH >>>>>>>>>>>>>>>>>>>>>> generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>>>> int main() { return
HHH(main);
}
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>>>>>> which he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>>>> words.
It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>>>> correctly simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>> termination.
The input to HHH(main) when correctly simulated by HHH cannot >>>>>>>>>>>>> possibly terminate normally.
The input to HHH, which is main(), terminates. HHH does not >>>>>>>>>>>> simulate that.
The directly executed main() relies on HHH aborting the
simulation of its input. HHH cannot rely on anything else >>>>>>>>>>> aborting the simulation of its input.
The simulating HHH should rely on the simulated HHH to abort. >>>>>>>>>
Indeed and since it is false that the simulated HHH would not abort, >>>>>
Since each HHH is exactly the same unless the first one aborts none of >>>>> them do.
And thus, the one that DD calls aborts.
Hey, let me prove all programs are no-ops, by NOT SIMULATING THEM MWAHAHA
DD correctly simulated by HHH cannot possibly terminate normally.
On 2/14/2025 6:58 AM, joes wrote:
Am Fri, 14 Feb 2025 06:42:29 -0600 schrieb olcott:
On 2/14/2025 3:36 AM, joes wrote:Oh, but we’re not interested in the behaviour of HHH(HHH(DD)).
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 10:02 PM, olcott wrote:
What is the non-input?The correct simulation is only the one that it sees by definition. it >>>>> maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.Anyone that knows the C language sufficiently well knows that DD >>>>>>> correctly simulated by HHH cannot possibly terminate normally.Since there is a 5% chance that the treatment I will have next >>>>>>>>> month will kill me and this treatment is my only good chance I >>>>>>>>> will totally ignore anything that diverges from the point.Ok, I will wait a month then.
Indeed, which shows the limitation of HHH which makes that it cannot >>>>>> properly decide about its input, because it must abort the correct >>>>>> simulation before it sees that the correct simulation terminates
normally.
All of the people that think it should map the behavior of a non-input >>>>> have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
DD correctly simulated by HHH cannot possibly terminate normally.
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see that the simulated HHH would also abort, so that the simulating HHH does not need
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams are no
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero
I reject infinite deflection away from the point. The absolute >>>>>>>>> single-mined focus point is that DD correctly simulated by HHH >>>>>>>>> cannotOh goody, you’re never getting anywhere if you rejectI am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>>>> accordingThe directly executed HHH(DD) always halts and returns >>>>>>>>>>>>>>>>> a correctHHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>>>>>> correct value.If this was true then you could point out exactly >>>>>>>>>>>>>>>>>>> where HHH iscorrectly.simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>>>> itselfSo, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>> understand thiscomplete its simulation, because HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All >>>>>>>>>>>>>>>>>>>>>>>>>>>> other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, etc.) >>>>>>>>>>>>>>>>>>>>>>>>>>>> show
that DD halts. But HHH fails to see it. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Everyone with
sufficient understanding of programming sees >>>>>>>>>>>>>>>>>>>>>>>>>>>> that HHH
is not correctly programmed when it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>> one cycle
before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is >>>>>>>>>>>>>>>>>>>>>>>>>> unable to
simple proof that HHH produces false negatives. >>>>>>>>>>>>>>>>>>>>>>>> HHH is
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>> termination.
but he denies it.
He lacks the ability to accept simple verified >>>>>>>>>>>>>>>>>>>>>> facts, which
he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>>>> correctly
incorrect.
value as soon as it correctly determines that its input >>>>>>>>>>>>>>>>> cannot
possibly terminate normally.
to spec, so does the inner, because it is the same. >>>>>>>>>>>>>>>> Therefore it
can’t report „non-halting” and be correct. If the inner HHH
doesn’t halt, it is not a decider.
corrections.
possible terminate normally.
Since there is a 5% chance that the treatment I will have next >>>>>>>>> monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will >>>>>>>>> totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate
normally.
Indeed, which shows the limitation of HHH which makes that it
cannot properly decide about its input, because it must abort the >>>>>> correct simulation before it sees that the correct simulation
terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
If I close my eyes, so that I do not see the accident, I cannot
claim that the accident did not happen. That is the reasoning of a 2
years old child.
HHH(DD) maps the finite string input of DD to the behavior that it
specifies. This behavior does include DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly terminate normally.
substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and does not
see that the simulated HHH also aborts so that the program terminates
normally.
It is only your lack of technical competence that makes it seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
On 2/14/2025 7:55 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 13:42 schreef olcott:
On 2/14/2025 3:36 AM, joes wrote:
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:What is the non-input?
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott:
On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/6/25 10:02 PM, olcott wrote:
The correct simulation is only the one that it sees by definition. it >>>>> maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.Anyone that knows the C language sufficiently well knows that DD >>>>>>> correctly simulated by HHH cannot possibly terminate normally.That IS the point. DD does nothing else than call HHH.I reject infinite deflection away from the point. The absolute >>>>>>>>> single-mined focus point is that DD correctly simulated by HHH >>>>>>>>> cannot possible terminate normally.Oh goody, you’re never getting anywhere if you rejectI am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>>>> according to spec, so does the inner, because it is the >>>>>>>>>>>>>>>> same.The directly executed HHH(DD) always halts and returns a >>>>>>>>>>>>>>>>> correct value as soon as it correctly determines that its >>>>>>>>>>>>>>>>> input cannot possibly terminate normally.HHH is supposed to be a decider, i.e. halt and return the >>>>>>>>>>>>>>>>>> correct value.If this was true then you could point out exactly where >>>>>>>>>>>>>>>>>>> HHH is incorrect.Indeed, which proves that HHH is unable to simulate >>>>>>>>>>>>>>>>>>>> itself correctly.It is a verified fact that main cannot possibly be >>>>>>>>>>>>>>>>>>>>> correctly simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>> termination.So, in other words, Olcott denies verified facts. HHH >>>>>>>>>>>>>>>>>>>>>> generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even understand >>>>>>>>>>>>>>>>>>>>>>>> this simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>> negatives.The execution trace only shows that HHH is unable >>>>>>>>>>>>>>>>>>>>>>>>>> to complete its simulation, because HHH is unable >>>>>>>>>>>>>>>>>>>>>>>>>> to simulate itself.Which proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All >>>>>>>>>>>>>>>>>>>>>>>>>>>> other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, etc.) >>>>>>>>>>>>>>>>>>>>>>>>>>>> show
that DD halts. But HHH fails to see it. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Everyone
with sufficient understanding of programming >>>>>>>>>>>>>>>>>>>>>>>>>>>> sees
that HHH is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle before the simulation would >>>>>>>>>>>>>>>>>>>>>>>>>>>> end
normally.
HHH is unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>> termination.
but he denies it.
He lacks the ability to accept simple verified facts, >>>>>>>>>>>>>>>>>>>>>> which he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>>>> words.
Therefore it can’t report „non-halting” and be correct. If
the inner HHH doesn’t halt, it is not a decider.
corrections.
Since there is a 5% chance that the treatment I will have next >>>>>>>>> monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will >>>>>>>>> totally ignore anything that diverges from the point.
Indeed, which shows the limitation of HHH which makes that it cannot >>>>>> properly decide about its input, because it must abort the correct >>>>>> simulation before it sees that the correct simulation terminates
normally.
All of the people that think it should map the behavior of a non-input >>>>> have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
What is the difference in the finite string that describes the first
DD and the finite string that describes the second DD?
The directly executed DD only halts because HHH aborts its
simulated DD.
DD correctly simulated by HHH cannot possibly terminate normally.
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see that
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams are no
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero
I reject infinite deflection away from the point. The absolute >>>>>>>>>>> single-mined focus point is that DD correctly simulated by >>>>>>>>>>> HHH cannotOh goody, you’re never getting anywhere if you reject >>>>>>>>>>>> corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>>>>>> accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>> returns a correctHHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>> return theIf this was true then you could point out exactly >>>>>>>>>>>>>>>>>>>>> where HHH iscorrectly.simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>> simulate itselfSo, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>> understand thiscomplete its simulation, because HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>> unable toWhich proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> etc.) show
that DD halts. But HHH fails to see it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Everyone with
sufficient understanding of programming >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees that HHH
is not correctly programmed when it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one cycle
before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to
simulate itself.
simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>>>> termination.
but he denies it.
He lacks the ability to accept simple verified >>>>>>>>>>>>>>>>>>>>>>>> facts, which
he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly >>>>>>>>>>>>>>>>>>>>>>> be correctly
incorrect.
correct value.
value as soon as it correctly determines that its >>>>>>>>>>>>>>>>>>> input cannot
possibly terminate normally.
to spec, so does the inner, because it is the same. >>>>>>>>>>>>>>>>>> Therefore it
can’t report „non-halting” and be correct. If the >>>>>>>>>>>>>>>>>> inner HHH
doesn’t halt, it is not a decider.
possible terminate normally.
Since there is a 5% chance that the treatment I will have >>>>>>>>>>> next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will >>>>>>>>>>> totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate >>>>>>>>> normally.
Indeed, which shows the limitation of HHH which makes that it
cannot properly decide about its input, because it must abort >>>>>>>> the correct simulation before it sees that the correct
simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
If I close my eyes, so that I do not see the accident, I cannot
claim that the accident did not happen. That is the reasoning of a >>>>>> 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior that it
specifies. This behavior does include DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly terminate normally. >>>>>
substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and does
not see that the simulated HHH also aborts so that the program
terminates normally.
It is only your lack of technical competence that makes it seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly
get to the point where it sees that it needs to abort because it
is aborted before it gets to this point.
Unless the outermost HHH aborts before any inner HHH sees that
it needs to abort no HHH ever aborts. You simply do not understand
these things well enough to verify the actual facts.
On 2/15/2025 2:11 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 00:30 schreef olcott:
On 2/14/2025 6:58 AM, joes wrote:
Am Fri, 14 Feb 2025 06:42:29 -0600 schrieb olcott:
On 2/14/2025 3:36 AM, joes wrote:Oh, but we’re not interested in the behaviour of HHH(HHH(DD)).
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
What is the non-input?The correct simulation is only the one that it sees byIndeed, which shows the limitation of HHH which makes that itAnyone that knows the C language sufficiently well knows that DD >>>>>>>>> correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>Since there is a 5% chance that the treatment I will have next >>>>>>>>>>> month will kill me and this treatment is my only good chance I >>>>>>>>>>> will totally ignore anything that diverges from the point. >>>>>>>>>> Ok, I will wait a month then.
cannot
properly decide about its input, because it must abort the correct >>>>>>>> simulation before it sees that the correct simulation terminates >>>>>>>> normally.
definition. it
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non- >>>>>>> input
have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
DD correctly simulated by HHH cannot possibly terminate normally.
Proving the failure to decide by simulation.
That would be isomorphic to saying that cows prove that
mammals do not exist.
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see that
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams are no
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH.
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, Bonita >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Montero
I reject infinite deflection away from the point. The absolute >>>>>>>>>>> single-mined focus point is that DD correctly simulated by >>>>>>>>>>> HHH cannotOh goody, you’re never getting anywhere if you reject >>>>>>>>>>>> corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH halts >>>>>>>>>>>>>>>>>> accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>> returns a correctHHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>> return theIf this was true then you could point out exactly >>>>>>>>>>>>>>>>>>>>> where HHH iscorrectly.simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>> simulate itselfSo, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>> }It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>> understand thiscomplete its simulation, because HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>> unable toWhich proves that HHH fails to make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting behaviour. All >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> etc.) show
that DD halts. But HHH fails to see it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Everyone with
sufficient understanding of programming >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees that HHH
is not correctly programmed when it aborts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> one cycle
before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to
simulate itself.
simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>>>> termination.
but he denies it.
He lacks the ability to accept simple verified >>>>>>>>>>>>>>>>>>>>>>>> facts, which
he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly >>>>>>>>>>>>>>>>>>>>>>> be correctly
incorrect.
correct value.
value as soon as it correctly determines that its >>>>>>>>>>>>>>>>>>> input cannot
possibly terminate normally.
to spec, so does the inner, because it is the same. >>>>>>>>>>>>>>>>>> Therefore it
can’t report „non-halting” and be correct. If the >>>>>>>>>>>>>>>>>> inner HHH
doesn’t halt, it is not a decider.
possible terminate normally.
Since there is a 5% chance that the treatment I will have >>>>>>>>>>> next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I will >>>>>>>>>>> totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows
that DD correctly simulated by HHH cannot possibly terminate >>>>>>>>> normally.
Indeed, which shows the limitation of HHH which makes that it
cannot properly decide about its input, because it must abort >>>>>>>> the correct simulation before it sees that the correct
simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
If I close my eyes, so that I do not see the accident, I cannot
claim that the accident did not happen. That is the reasoning of a >>>>>> 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior that it
specifies. This behavior does include DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly terminate normally. >>>>>
substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and does
not see that the simulated HHH also aborts so that the program
terminates normally.
It is only your lack of technical competence that makes it seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly
get to the point where it sees that it needs to abort because it
is aborted before it gets to this point.
On 2/15/2025 2:11 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 00:30 schreef olcott:
On 2/14/2025 6:58 AM, joes wrote:
Am Fri, 14 Feb 2025 06:42:29 -0600 schrieb olcott:
On 2/14/2025 3:36 AM, joes wrote:Oh, but we’re not interested in the behaviour of HHH(HHH(DD)).
Am Thu, 13 Feb 2025 18:12:52 -0600 schrieb olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote:
What is the non-input?The correct simulation is only the one that it sees byIndeed, which shows the limitation of HHH which makes that itAnyone that knows the C language sufficiently well knows that DD >>>>>>>>> correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>Since there is a 5% chance that the treatment I will have next >>>>>>>>>>> month will kill me and this treatment is my only good chance I >>>>>>>>>>> will totally ignore anything that diverges from the point. >>>>>>>>>> Ok, I will wait a month then.
cannot
properly decide about its input, because it must abort the correct >>>>>>>> simulation before it sees that the correct simulation terminates >>>>>>>> normally.
definition. it
maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.
All of the people that think it should map the behavior of a non- >>>>>>> input
have always been wrong.
int main()
{
DD(); // Is not an input to HHH
HHH(DD) // Is an input to HHH
{
The input is DD, and its behaviour is that it halts.
HHH’s simulation is not correct by definition.
DD correctly simulated by HHH cannot possibly terminate normally.
Proving the failure to decide by simulation.
That would be isomorphic to saying that cows prove that
mammals do not exist.
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott:
On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon
Yes, but why does it need to be stopped before it halts?Which does not change the fact that simulating HHH does not see thatIt is only your lack of technical competence that makes it seem thatOlcott is again dreaming of a HHH that does not abort. Dreams are noThe correct simulation is only the one that it sees by definition. >>>>>>> it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.Indeed, which shows the limitation of HHH which makes that itAnyone that knows the C language sufficiently well knows that DD >>>>>>>>> correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>Since there is a 5% chance that the treatment I will have next >>>>>>>>>>> month will kill me and this treatment is my only good chance I >>>>>>>>>>> will totally ignore anything that diverges from the point. >>>>>>>>>> Ok, I will wait a month then.
cannot properly decide about its input, because it must abort >>>>>>>> the correct simulation before it sees that the correct simulation >>>>>>>> terminates normally.
If I close my eyes, so that I do not see the accident, I cannot
claim that the accident did not happen. That is the reasoning of a >>>>>> 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior that it
specifies. This behavior does include DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly terminate
normally.
substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and does
not see that the simulated HHH also aborts so that the program
terminates normally.
(a) The simulated HHH aborts its simulation after itself is no longer
being simulated.
(b) Either the outermost HHH aborts its simulation of none of them do.
the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly get to
the point where it sees that it needs to abort because it is aborted
before it gets to this point.
Unless the outermost HHH aborts before any inner HHH sees that it needsTrue. No HHH should ever abort.
to abort no HHH ever aborts.
On 2/16/2025 6:50 AM, joes wrote:
Am Sat, 15 Feb 2025 13:21:10 -0600 schrieb olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon
the simulated HHH would also abort,It is only your lack of technical competence that makes it seem that >>>>> (a) The simulated HHH aborts its simulation after itself is no longer >>>>> being simulated.Olcott is again dreaming of a HHH that does not abort. Dreams are no >>>>>> substitute for reasoning.The correct simulation is only the one that it sees by definition. >>>>>>>>> it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT.Indeed, which shows the limitation of HHH which makes that it >>>>>>>>>> cannot properly decide about its input, because it must abort >>>>>>>>>> the correct simulation before it sees that the correct simulation >>>>>>>>>> terminates normally.Anyone that knows the C language sufficiently well knows that DD >>>>>>>>>>> correctly simulated by HHH cannot possibly terminate normally. >>>>>>>>>>Since there is a 5% chance that the treatment I will have next >>>>>>>>>>>>> month will kill me and this treatment is my only good chance I >>>>>>>>>>>>> will totally ignore anything that diverges from the point. >>>>>>>>>>>> Ok, I will wait a month then.
If I close my eyes, so that I do not see the accident, I cannot >>>>>>>> claim that the accident did not happen. That is the reasoning of a >>>>>>>> 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior that it >>>>>>> specifies. This behavior does include DD repeatedly calling HHH(DD) >>>>>>> in recursive simulation that that cannot possibly terminate
normally.
The simulating HHH aborts the simulation, closes its eyes and does >>>>>> not see that the simulated HHH also aborts so that the program
terminates normally.
(b) Either the outermost HHH aborts its simulation of none of them do. >>>> Which does not change the fact that simulating HHH does not see that
The simulated HHH cannot possibly abort because it can't possibly get to >>> the point where it sees that it needs to abort because it is aborted
before it gets to this point.
Yes, but why does it need to be stopped before it halts?I had to rewrite this reply five times because Thunderbird
kept screwing up. I forgot my original words.
No DD simulated by any corresponding HHH can possibly ever terminate
normally if you disagree that only proves that you don't know C well
enough.
Unless the outermost HHH aborts before any inner HHH sees that it needsTrue. No HHH should ever abort.
to abort no HHH ever aborts.
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see that
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams are
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:If I close my eyes, so that I do not see the accident, I cannot >>>>>>>> claim that the accident did not happen. That is the reasoning of >>>>>>>> a 2 years old child.
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott:
On 2/11/2025 2:05 PM, joes wrote:That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>
Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote:
Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bonita Montero
I reject infinite deflection away from the point. The absolute >>>>>>>>>>>>> single-mined focus point is that DD correctly simulated by >>>>>>>>>>>>> HHH cannotOh goody, you’re never getting anywhere if you reject >>>>>>>>>>>>>> corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH >>>>>>>>>>>>>>>>>>>> halts accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>>>> returns a correctHHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>>>> return theIf this was true then you could point out exactly >>>>>>>>>>>>>>>>>>>>>>> where HHH iscorrectly.simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>> simulate itselfSo, in other words, Olcott denies verified facts. >>>>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is verified in >>>>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it.It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>>>> understand thiscomplete its simulation, because HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable toWhich proves that HHH fails to make a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
decision about DD's halting behaviour. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> etc.) show
that DD halts. But HHH fails to see it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Everyone with
sufficient understanding of programming >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees that HHH
is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to
simulate itself.
simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>>>>>> termination.
He lacks the ability to accept simple verified >>>>>>>>>>>>>>>>>>>>>>>>>> facts, which
he tries to hide with a lot of irrelevant words. >>>>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot possibly >>>>>>>>>>>>>>>>>>>>>>>>> be correctly
incorrect.
correct value.
value as soon as it correctly determines that its >>>>>>>>>>>>>>>>>>>>> input cannot
possibly terminate normally.
to spec, so does the inner, because it is the same. >>>>>>>>>>>>>>>>>>>> Therefore it
can’t report „non-halting” and be correct. If the >>>>>>>>>>>>>>>>>>>> inner HHH
doesn’t halt, it is not a decider.
possible terminate normally.
Since there is a 5% chance that the treatment I will have >>>>>>>>>>>>> next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I >>>>>>>>>>>>> will totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>> that DD correctly simulated by HHH cannot possibly terminate >>>>>>>>>>> normally.
Indeed, which shows the limitation of HHH which makes that it >>>>>>>>>> cannot properly decide about its input, because it must abort >>>>>>>>>> the correct simulation before it sees that the correct
simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT. >>>>>>>>
HHH(DD) maps the finite string input of DD to the behavior that
it specifies. This behavior does include DD repeatedly calling
HHH(DD)
in recursive simulation that that cannot possibly terminate
normally.
no substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and does >>>>>> not see that the simulated HHH also aborts so that the program
terminates normally.
It is only your lack of technical competence that makes it seem that >>>>> (a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly
get to the point where it sees that it needs to abort because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where the
simulated HHH aborts and halts. The simulating misses in this way
relevant details of the program given in its input. That is the reason
why it fails. It is unable to see the whole input, because it gets
stuck in recursive simulation of itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:If I close my eyes, so that I do not see the accident, I
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bonita Montero
I reject infinite deflection away from the point. The >>>>>>>>>>>>>>> absoluteOh goody, you’re never getting anywhere if you reject >>>>>>>>>>>>>>>> corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH >>>>>>>>>>>>>>>>>>>>>> halts accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>>>>>> returns a correctHHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>>>>>> return theIf this was true then you could point out >>>>>>>>>>>>>>>>>>>>>>>>> exactly where HHH iscorrectly.It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctlySo, in other words, Olcott denies verified >>>>>>>>>>>>>>>>>>>>>>>>>>>> facts.simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH iscomplete its simulation, because HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable toWhich proves that HHH fails to make a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
decision about DD's halting behaviour. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is unable to
simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand this
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination.
HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in
int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it.
He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which
he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>>>>>>>>>> words.
simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself
incorrect.
correct value.
value as soon as it correctly determines that its >>>>>>>>>>>>>>>>>>>>>>> input cannot
possibly terminate normally.
to spec, so does the inner, because it is the >>>>>>>>>>>>>>>>>>>>>> same. Therefore it
can’t report „non-halting” and be correct. If the >>>>>>>>>>>>>>>>>>>>>> inner HHH
doesn’t halt, it is not a decider.
single-mined focus point is that DD correctly simulated >>>>>>>>>>>>>>> by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will have >>>>>>>>>>>>>>> next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I >>>>>>>>>>>>>>> will totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>>>> that DD correctly simulated by HHH cannot possibly
terminate normally.
Indeed, which shows the limitation of HHH which makes that >>>>>>>>>>>> it cannot properly decide about its input, because it must >>>>>>>>>>>> abort the correct simulation before it sees that the correct >>>>>>>>>>>> simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT. >>>>>>>>>>
cannot claim that the accident did not happen. That is the >>>>>>>>>> reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior that >>>>>>>>> it specifies. This behavior does include DD repeatedly calling >>>>>>>>> HHH(DD)
in recursive simulation that that cannot possibly terminate
normally.
are no substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and
does not see that the simulated HHH also aborts so that the
program terminates normally.
It is only your lack of technical competence that makes it seem that >>>>>>> (a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
that the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly
get to the point where it sees that it needs to abort because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where the
simulated HHH aborts and halts. The simulating misses in this way
relevant details of the program given in its input. That is the
reason why it fails. It is unable to see the whole input, because it
gets stuck in recursive simulation of itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
It only reports that the simulation was aborted. Not more, not less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:If I close my eyes, so that I do not see the accident, I
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote:
Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bonita Montero
I reject infinite deflection away from the point. The >>>>>>>>>>>>>>> absoluteOh goody, you’re never getting anywhere if you reject >>>>>>>>>>>>>>>> corrections.I am not going to ever talk about that.We were talking about HHH(HHH). If the outer HHH >>>>>>>>>>>>>>>>>>>>>> halts accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>>>>>> returns a correctHHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>>>>>> return theIf this was true then you could point out >>>>>>>>>>>>>>>>>>>>>>>>> exactly where HHH iscorrectly.It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctlySo, in other words, Olcott denies verified >>>>>>>>>>>>>>>>>>>>>>>>>>>> facts.simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH iscomplete its simulation, because HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable toWhich proves that HHH fails to make a >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct
decision about DD's halting behaviour. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All other
methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class simulator, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is unable to
simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand this
unable to simulate itself up to the normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination.
HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in
int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it.
He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which
he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>>>>>>>>>> words.
simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself
incorrect.
correct value.
value as soon as it correctly determines that its >>>>>>>>>>>>>>>>>>>>>>> input cannot
possibly terminate normally.
to spec, so does the inner, because it is the >>>>>>>>>>>>>>>>>>>>>> same. Therefore it
can’t report „non-halting” and be correct. If the >>>>>>>>>>>>>>>>>>>>>> inner HHH
doesn’t halt, it is not a decider.
single-mined focus point is that DD correctly simulated >>>>>>>>>>>>>>> by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will have >>>>>>>>>>>>>>> next monthOk, I will wait a month then.
will kill me and this treatment is my only good chance I >>>>>>>>>>>>>>> will totally
ignore anything that diverges from the point.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>>>> that DD correctly simulated by HHH cannot possibly
terminate normally.
Indeed, which shows the limitation of HHH which makes that >>>>>>>>>>>> it cannot properly decide about its input, because it must >>>>>>>>>>>> abort the correct simulation before it sees that the correct >>>>>>>>>>>> simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS INPUT. >>>>>>>>>>
cannot claim that the accident did not happen. That is the >>>>>>>>>> reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior that >>>>>>>>> it specifies. This behavior does include DD repeatedly calling >>>>>>>>> HHH(DD)
in recursive simulation that that cannot possibly terminate
normally.
are no substitute for reasoning.
The simulating HHH aborts the simulation, closes its eyes and
does not see that the simulated HHH also aborts so that the
program terminates normally.
It is only your lack of technical competence that makes it seem that >>>>>>> (a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
that the simulated HHH would also abort,
The simulated HHH cannot possibly abort because it can't possibly
get to the point where it sees that it needs to abort because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where the
simulated HHH aborts and halts. The simulating misses in this way
relevant details of the program given in its input. That is the
reason why it fails. It is unable to see the whole input, because it
gets stuck in recursive simulation of itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
It only reports that the simulation was aborted. Not more, not less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see >>>>>>>> that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams >>>>>>>>>> are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>>>Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:I reject infinite deflection away from the point. The >>>>>>>>>>>>>>>>> absolute
Oh goody, you’re never getting anywhere if you reject >>>>>>>>>>>>>>>>>> corrections.Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
We were talking about HHH(HHH). If the outer HHH >>>>>>>>>>>>>>>>>>>>>>>> halts accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>>>>>>>> returns a correctOn 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bonita Montero >>>>>>>>>>>>>>>>HHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>>>>>>>> return the
If this was true then you could point out >>>>>>>>>>>>>>>>>>>>>>>>>>> exactly where HHH iscorrectly.It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itselfHHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified inWhich proves that HHH fails to make >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies verified >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> facts.
int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it.
He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words.
incorrect.
correct value.
value as soon as it correctly determines that >>>>>>>>>>>>>>>>>>>>>>>>> its input cannot
possibly terminate normally.
to spec, so does the inner, because it is the >>>>>>>>>>>>>>>>>>>>>>>> same. Therefore it
can’t report „non-halting” and be correct. If >>>>>>>>>>>>>>>>>>>>>>>> the inner HHH
doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>> I am not going to ever talk about that.
single-mined focus point is that DD correctly simulated >>>>>>>>>>>>>>>>> by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will >>>>>>>>>>>>>>>>> have next month
will kill me and this treatment is my only good chance >>>>>>>>>>>>>>>>> I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>>>>>> that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which makes that >>>>>>>>>>>>>> it cannot properly decide about its input, because it >>>>>>>>>>>>>> must abort the correct simulation before it sees that the >>>>>>>>>>>>>> correct simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS >>>>>>>>>>>>> INPUT.
If I close my eyes, so that I do not see the accident, I >>>>>>>>>>>> cannot claim that the accident did not happen. That is the >>>>>>>>>>>> reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior >>>>>>>>>>> that it specifies. This behavior does include DD repeatedly >>>>>>>>>>> calling HHH(DD)
in recursive simulation that that cannot possibly terminate >>>>>>>>>>> normally.
The simulating HHH aborts the simulation, closes its eyes and >>>>>>>>>> does not see that the simulated HHH also aborts so that the >>>>>>>>>> program terminates normally.
It is only your lack of technical competence that makes it seem >>>>>>>>> that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
The simulated HHH cannot possibly abort because it can't possibly >>>>>>> get to the point where it sees that it needs to abort because it >>>>>>> is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where the
simulated HHH aborts and halts. The simulating misses in this way
relevant details of the program given in its input. That is the
reason why it fails. It is unable to see the whole input, because
it gets stuck in recursive simulation of itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
It only reports that the simulation was aborted. Not more, not less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up to
the normal termination of the program described by the finite string.
Good.
However, Olcott fails to see that it is a failure of HHH to be unable
to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of failure.
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:Olcott fails to see that, even the logically impossible is impossible.
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:That you do not understand the term: "terminates normally"
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not >>>>>>>>>> see that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. >>>>>>>>>>>> Dreams are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>>>>>Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:I reject infinite deflection away from the point. The >>>>>>>>>>>>>>>>>>> absolute
Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:to spec, so does the inner, because it is the >>>>>>>>>>>>>>>>>>>>>>>>>> same. Therefore it
The directly executed HHH(DD) always halts >>>>>>>>>>>>>>>>>>>>>>>>>>> and returns a correctOn 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bonita Montero >>>>>>>>>>>>>>>>>>HHH is supposed to be a decider, i.e. halt >>>>>>>>>>>>>>>>>>>>>>>>>>>> and return the
If this was true then you could point out >>>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly where HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itselfint main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main);Which proves that HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in
} >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination.
correctly.
correct value.
value as soon as it correctly determines that >>>>>>>>>>>>>>>>>>>>>>>>>>> its input cannot
possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>> We were talking about HHH(HHH). If the outer >>>>>>>>>>>>>>>>>>>>>>>>>> HHH halts according
can’t report „non-halting” and be correct. If >>>>>>>>>>>>>>>>>>>>>>>>>> the inner HHH
doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>>>> I am not going to ever talk about that. >>>>>>>>>>>>>>>>>>>> Oh goody, you’re never getting anywhere if you >>>>>>>>>>>>>>>>>>>> reject corrections.
single-mined focus point is that DD correctly >>>>>>>>>>>>>>>>>>> simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will >>>>>>>>>>>>>>>>>>> have next month
will kill me and this treatment is my only good >>>>>>>>>>>>>>>>>>> chance I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>>>>>>>> that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which makes >>>>>>>>>>>>>>>> that it cannot properly decide about its input, because >>>>>>>>>>>>>>>> it must abort the correct simulation before it sees that >>>>>>>>>>>>>>>> the correct simulation terminates normally.
The correct simulation is only the one that it sees >>>>>>>>>>>>>>> by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS >>>>>>>>>>>>>>> INPUT.
If I close my eyes, so that I do not see the accident, I >>>>>>>>>>>>>> cannot claim that the accident did not happen. That is the >>>>>>>>>>>>>> reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior >>>>>>>>>>>>> that it specifies. This behavior does include DD repeatedly >>>>>>>>>>>>> calling HHH(DD)
in recursive simulation that that cannot possibly terminate >>>>>>>>>>>>> normally.
The simulating HHH aborts the simulation, closes its eyes >>>>>>>>>>>> and does not see that the simulated HHH also aborts so that >>>>>>>>>>>> the program terminates normally.
It is only your lack of technical competence that makes it >>>>>>>>>>> seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
The simulated HHH cannot possibly abort because it can't possibly >>>>>>>>> get to the point where it sees that it needs to abort because it >>>>>>>>> is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where
the simulated HHH aborts and halts. The simulating misses in
this way relevant details of the program given in its input.
That is the reason why it fails. It is unable to see the whole >>>>>>>> input, because it gets stuck in recursive simulation of itself. >>>>>>>>
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
It only reports that the simulation was aborted. Not more, not less. >>>>>
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up to
the normal termination of the program described by the finite string.
Good.
However, Olcott fails to see that it is a failure of HHH to be
unable to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of failure. >>>
He thinks that he can claim that it is possible by changing the
definitions.
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not see >>>>>>>> that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. Dreams >>>>>>>>>> are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>>>Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote:I reject infinite deflection away from the point. The >>>>>>>>>>>>>>>>> absolute
Oh goody, you’re never getting anywhere if you reject >>>>>>>>>>>>>>>>>> corrections.Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote:
Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
We were talking about HHH(HHH). If the outer HHH >>>>>>>>>>>>>>>>>>>>>>>> halts accordingThe directly executed HHH(DD) always halts and >>>>>>>>>>>>>>>>>>>>>>>>> returns a correctOn 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Bonita Montero >>>>>>>>>>>>>>>>HHH is supposed to be a decider, i.e. halt and >>>>>>>>>>>>>>>>>>>>>>>>>> return the
If this was true then you could point out >>>>>>>>>>>>>>>>>>>>>>>>>>> exactly where HHH iscorrectly.It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itselfHHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified inWhich proves that HHH fails to make >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to see >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows that >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not even >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies verified >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> facts.
int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main); >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> } >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it.
He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of irrelevant >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> words.
incorrect.
correct value.
value as soon as it correctly determines that >>>>>>>>>>>>>>>>>>>>>>>>> its input cannot
possibly terminate normally.
to spec, so does the inner, because it is the >>>>>>>>>>>>>>>>>>>>>>>> same. Therefore it
can’t report „non-halting” and be correct. If >>>>>>>>>>>>>>>>>>>>>>>> the inner HHH
doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>> I am not going to ever talk about that.
single-mined focus point is that DD correctly simulated >>>>>>>>>>>>>>>>> by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I will >>>>>>>>>>>>>>>>> have next month
will kill me and this treatment is my only good chance >>>>>>>>>>>>>>>>> I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>>>>>> that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which makes that >>>>>>>>>>>>>> it cannot properly decide about its input, because it >>>>>>>>>>>>>> must abort the correct simulation before it sees that the >>>>>>>>>>>>>> correct simulation terminates normally.
The correct simulation is only the one that it sees
by definition. it maps ITS INPUT TO THE BEHAVIOR OF THIS >>>>>>>>>>>>> INPUT.
If I close my eyes, so that I do not see the accident, I >>>>>>>>>>>> cannot claim that the accident did not happen. That is the >>>>>>>>>>>> reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the behavior >>>>>>>>>>> that it specifies. This behavior does include DD repeatedly >>>>>>>>>>> calling HHH(DD)
in recursive simulation that that cannot possibly terminate >>>>>>>>>>> normally.
The simulating HHH aborts the simulation, closes its eyes and >>>>>>>>>> does not see that the simulated HHH also aborts so that the >>>>>>>>>> program terminates normally.
It is only your lack of technical competence that makes it seem >>>>>>>>> that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
The simulated HHH cannot possibly abort because it can't possibly >>>>>>> get to the point where it sees that it needs to abort because it >>>>>>> is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where the
simulated HHH aborts and halts. The simulating misses in this way
relevant details of the program given in its input. That is the
reason why it fails. It is unable to see the whole input, because
it gets stuck in recursive simulation of itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly
terminate normally.
It only reports that the simulation was aborted. Not more, not less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up to
the normal termination of the program described by the finite string.
Good.
However, Olcott fails to see that it is a failure of HHH to be unable
to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of failure.
In his citation he deleted my suggestion to change his simulator.
To the best of my knowledge any change would be erroneous.
Instead of aborting the simulation at the call to HHH, he could
replace this call with the correct return value of HHH
If you understand this code then you can see that this is is not what
the code itself specifies.
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
HHH(DD);
}
HHH[0] simulates DD[0]
that calls HHH[1] on its line 1 to simulate DD[1]
that calls HHH[2] on its line 1 to simulate DD[2]
that calls HHH[3] on its line 1 to simulate DD[3]...
(which he seems to know) and then continue the simulation of DD. This
avoids the recursion introduced by the simulator.
We cannot simply ignore the call to HHH(DD) from DD
and replace this call with different code and construe
this as a correct simulation.
*Here is what you seem to be saying, HHH changes this code*
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
*To this code*
int DD()
{
return 1;
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
On 2/17/2025 2:16 PM, Fred. Zwarts wrote:
Op 17.feb.2025 om 18:11 schreef olcott:
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:Olcott fails to see that, even the logically impossible is
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not >>>>>>>>>>>> see that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. >>>>>>>>>>>>>> Dreams are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote:
Op 13.feb.2025 om 13:31 schreef olcott:
On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>>>>>>>Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:I reject infinite deflection away from the point. >>>>>>>>>>>>>>>>>>>>> The absolute
On 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:to spec, so does the inner, because it is >>>>>>>>>>>>>>>>>>>>>>>>>>>> the same. Therefore it >>>>>>>>>>>>>>>>>>>>>>>>>>>> can’t report „non-halting” and be correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>> If the inner HHH
The directly executed HHH(DD) always halts >>>>>>>>>>>>>>>>>>>>>>>>>>>>> and returns a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>> value as soon as it correctly determines >>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its input cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>> We were talking about HHH(HHH). If the outer >>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH halts accordingOn 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:HHH is supposed to be a decider, i.e. halt >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and return the
If this was true then you could point out >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> exactly where HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.Indeed, which proves that HHH is unable >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to simulate itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.} >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination.Op 09.feb.2025 om 16:18 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>
Which proves that HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed when >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces false >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main);
correct value.
doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>>>>>> I am not going to ever talk about that. >>>>>>>>>>>>>>>>>>>>>> Oh goody, you’re never getting anywhere if you >>>>>>>>>>>>>>>>>>>>>> reject corrections.
single-mined focus point is that DD correctly >>>>>>>>>>>>>>>>>>>>> simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I >>>>>>>>>>>>>>>>>>>>> will have next month
will kill me and this treatment is my only good >>>>>>>>>>>>>>>>>>>>> chance I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well knows >>>>>>>>>>>>>>>>>>> that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which makes >>>>>>>>>>>>>>>>>> that it cannot properly decide about its input, >>>>>>>>>>>>>>>>>> because it must abort the correct simulation before it >>>>>>>>>>>>>>>>>> sees that the correct simulation terminates normally. >>>>>>>>>>>>>>>>>>
The correct simulation is only the one that it sees >>>>>>>>>>>>>>>>> by definition. it maps ITS INPUT TO THE BEHAVIOR OF >>>>>>>>>>>>>>>>> THIS INPUT.
If I close my eyes, so that I do not see the accident, I >>>>>>>>>>>>>>>> cannot claim that the accident did not happen. That is >>>>>>>>>>>>>>>> the reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the >>>>>>>>>>>>>>> behavior that it specifies. This behavior does include DD >>>>>>>>>>>>>>> repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly >>>>>>>>>>>>>>> terminate normally.
The simulating HHH aborts the simulation, closes its eyes >>>>>>>>>>>>>> and does not see that the simulated HHH also aborts so >>>>>>>>>>>>>> that the program terminates normally.
It is only your lack of technical competence that makes it >>>>>>>>>>>>> seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation
of none of them do.
The simulated HHH cannot possibly abort because it can't >>>>>>>>>>> possibly
get to the point where it sees that it needs to abort because it >>>>>>>>>>> is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where >>>>>>>>>> the simulated HHH aborts and halts. The simulating misses in >>>>>>>>>> this way relevant details of the program given in its input. >>>>>>>>>> That is the reason why it fails. It is unable to see the whole >>>>>>>>>> input, because it gets stuck in recursive simulation of itself. >>>>>>>>>>
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly >>>>>>>>> terminate normally.
It only reports that the simulation was aborted. Not more, not >>>>>>>> less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up
to the normal termination of the program described by the finite
string.
Good.
However, Olcott fails to see that it is a failure of HHH to be
unable to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of
failure.
impossible. He thinks that he can claim that it is possible by
changing the definitions.
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
So, Olcott thinks that by changing the definitions he can create an
algorithm to encode a correct geometric square circle
*I didn't say anything like that*
That you said that did does not seem like any honest mistake.
On 2/17/2025 6:51 PM, Richard Damon wrote:
On 2/17/25 3:25 PM, olcott wrote:
On 2/17/2025 2:16 PM, Fred. Zwarts wrote:
Op 17.feb.2025 om 18:11 schreef olcott:
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:Olcott fails to see that, even the logically impossible is
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does >>>>>>>>>>>>>> not see that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. >>>>>>>>>>>>>>>> Dreams are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 13.feb.2025 om 13:31 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
That IS the point. DD does nothing else than call >>>>>>>>>>>>>>>>>>>>>> HHH.I reject infinite deflection away from the point. >>>>>>>>>>>>>>>>>>>>>>> The absoluteOn 2/10/2025 2:48 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>>>>>>>> I am not going to ever talk about that. >>>>>>>>>>>>>>>>>>>>>>>> Oh goody, you’re never getting anywhere if you >>>>>>>>>>>>>>>>>>>>>>>> reject corrections.
The directly executed HHH(DD) always >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts and returns a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value as soon as it correctly determines >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its input cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We were talking about HHH(HHH). If the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer HHH halts according >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to spec, so does the inner, because it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same. Therefore it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can’t report „non-halting” and be correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the inner HHHHHH is supposed to be a decider, i.e. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt and return the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct value.If this was true then you could point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out exactly where HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>
} >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> He lacks the ability to accept >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.Which proves that HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to see it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main);
single-mined focus point is that DD correctly >>>>>>>>>>>>>>>>>>>>>>> simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I >>>>>>>>>>>>>>>>>>>>>>> will have next month
will kill me and this treatment is my only good >>>>>>>>>>>>>>>>>>>>>>> chance I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well >>>>>>>>>>>>>>>>>>>>> knows
that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which >>>>>>>>>>>>>>>>>>>> makes that it cannot properly decide about its >>>>>>>>>>>>>>>>>>>> input, because it must abort the correct simulation >>>>>>>>>>>>>>>>>>>> before it sees that the correct simulation >>>>>>>>>>>>>>>>>>>> terminates normally.
The correct simulation is only the one that it sees >>>>>>>>>>>>>>>>>>> by definition. it maps ITS INPUT TO THE BEHAVIOR OF >>>>>>>>>>>>>>>>>>> THIS INPUT.
If I close my eyes, so that I do not see the accident, >>>>>>>>>>>>>>>>>> I cannot claim that the accident did not happen. That >>>>>>>>>>>>>>>>>> is the reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the >>>>>>>>>>>>>>>>> behavior that it specifies. This behavior does include >>>>>>>>>>>>>>>>> DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly >>>>>>>>>>>>>>>>> terminate normally.
The simulating HHH aborts the simulation, closes its >>>>>>>>>>>>>>>> eyes and does not see that the simulated HHH also aborts >>>>>>>>>>>>>>>> so that the program terminates normally.
It is only your lack of technical competence that makes >>>>>>>>>>>>>>> it seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation >>>>>>>>>>>>>>> of none of them do.
The simulated HHH cannot possibly abort because it can't >>>>>>>>>>>>> possibly
get to the point where it sees that it needs to abort >>>>>>>>>>>>> because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point >>>>>>>>>>>> where the simulated HHH aborts and halts. The simulating >>>>>>>>>>>> misses in this way relevant details of the program given in >>>>>>>>>>>> its input. That is the reason why it fails. It is unable to >>>>>>>>>>>> see the whole input, because it gets stuck in recursive >>>>>>>>>>>> simulation of itself.
This is all moot because the executed HHH recognizes this >>>>>>>>>>> pattern and correctly reports that its input cannot possibly >>>>>>>>>>> terminate normally.
It only reports that the simulation was aborted. Not more, not >>>>>>>>>> less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up >>>>>>>> to the normal termination of the program described by the finite >>>>>>>> string.
Good.
However, Olcott fails to see that it is a failure of HHH to be >>>>>>>> unable to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of
failure.
impossible. He thinks that he can claim that it is possible by
changing the definitions.
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
So, Olcott thinks that by changing the definitions he can create an
algorithm to encode a correct geometric square circle
*I didn't say anything like that*
That you said that did does not seem like any honest mistake.
But it is just as isomorphic to what you said as your "termination
analyzer" is to the Halting Problem.
THAT IS NOT THE TOPIC OF THE ABOVE REPLY.
On 2/17/2025 6:51 PM, Richard Damon wrote:Yes it is, but Olcott removed most of my reply in his citation, where I described how they are isomorphic.
On 2/17/25 3:25 PM, olcott wrote:
On 2/17/2025 2:16 PM, Fred. Zwarts wrote:
Op 17.feb.2025 om 18:11 schreef olcott:
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:Olcott fails to see that, even the logically impossible is
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does >>>>>>>>>>>>>> not see that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. >>>>>>>>>>>>>>>> Dreams are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 13.feb.2025 om 13:31 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>> Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
That IS the point. DD does nothing else than call >>>>>>>>>>>>>>>>>>>>>> HHH.I reject infinite deflection away from the point. >>>>>>>>>>>>>>>>>>>>>>> The absoluteOn 2/10/2025 2:48 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>>>>>>>> I am not going to ever talk about that. >>>>>>>>>>>>>>>>>>>>>>>> Oh goody, you’re never getting anywhere if you >>>>>>>>>>>>>>>>>>>>>>>> reject corrections.
The directly executed HHH(DD) always >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halts and returns a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value as soon as it correctly determines >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its input cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We were talking about HHH(HHH). If the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer HHH halts according >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to spec, so does the inner, because it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same. Therefore it >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can’t report „non-halting” and be correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the inner HHHHHH is supposed to be a decider, i.e. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt and return the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct value.If this was true then you could point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out exactly where HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM, Richard Damon >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>>
} >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> He lacks the ability to accept >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.Which proves that HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to see it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main);
single-mined focus point is that DD correctly >>>>>>>>>>>>>>>>>>>>>>> simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I >>>>>>>>>>>>>>>>>>>>>>> will have next month
will kill me and this treatment is my only good >>>>>>>>>>>>>>>>>>>>>>> chance I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well >>>>>>>>>>>>>>>>>>>>> knows
that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which >>>>>>>>>>>>>>>>>>>> makes that it cannot properly decide about its >>>>>>>>>>>>>>>>>>>> input, because it must abort the correct simulation >>>>>>>>>>>>>>>>>>>> before it sees that the correct simulation >>>>>>>>>>>>>>>>>>>> terminates normally.
The correct simulation is only the one that it sees >>>>>>>>>>>>>>>>>>> by definition. it maps ITS INPUT TO THE BEHAVIOR OF >>>>>>>>>>>>>>>>>>> THIS INPUT.
If I close my eyes, so that I do not see the accident, >>>>>>>>>>>>>>>>>> I cannot claim that the accident did not happen. That >>>>>>>>>>>>>>>>>> is the reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the >>>>>>>>>>>>>>>>> behavior that it specifies. This behavior does include >>>>>>>>>>>>>>>>> DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly >>>>>>>>>>>>>>>>> terminate normally.
The simulating HHH aborts the simulation, closes its >>>>>>>>>>>>>>>> eyes and does not see that the simulated HHH also aborts >>>>>>>>>>>>>>>> so that the program terminates normally.
It is only your lack of technical competence that makes >>>>>>>>>>>>>>> it seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation >>>>>>>>>>>>>>> of none of them do.
The simulated HHH cannot possibly abort because it can't >>>>>>>>>>>>> possibly
get to the point where it sees that it needs to abort >>>>>>>>>>>>> because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point >>>>>>>>>>>> where the simulated HHH aborts and halts. The simulating >>>>>>>>>>>> misses in this way relevant details of the program given in >>>>>>>>>>>> its input. That is the reason why it fails. It is unable to >>>>>>>>>>>> see the whole input, because it gets stuck in recursive >>>>>>>>>>>> simulation of itself.
This is all moot because the executed HHH recognizes this >>>>>>>>>>> pattern and correctly reports that its input cannot possibly >>>>>>>>>>> terminate normally.
It only reports that the simulation was aborted. Not more, not >>>>>>>>>> less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up >>>>>>>> to the normal termination of the program described by the finite >>>>>>>> string.
Good.
However, Olcott fails to see that it is a failure of HHH to be >>>>>>>> unable to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of
failure.
impossible. He thinks that he can claim that it is possible by
changing the definitions.
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
So, Olcott thinks that by changing the definitions he can create an
algorithm to encode a correct geometric square circle
*I didn't say anything like that*
That you said that did does not seem like any honest mistake.
But it is just as isomorphic to what you said as your "termination
analyzer" is to the Halting Problem.
THAT IS NOT THE TOPIC OF THE ABOVE REPLY.
On 2/17/25 3:25 PM, olcott wrote:
On 2/17/2025 2:16 PM, Fred. Zwarts wrote:
Op 17.feb.2025 om 18:11 schreef olcott:
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
On 2/17/2025 2:59 AM, Fred. Zwarts wrote:Olcott fails to see that, even the logically impossible is
Op 16.feb.2025 om 23:00 schreef olcott:
On 2/16/2025 2:16 PM, Fred. Zwarts wrote:
Op 16.feb.2025 om 13:58 schreef olcott:
On 2/16/2025 3:44 AM, Fred. Zwarts wrote:
Op 15.feb.2025 om 20:21 schreef olcott:
On 2/15/2025 2:06 AM, Fred. Zwarts wrote:
Op 14.feb.2025 om 22:18 schreef olcott:
On 2/14/2025 8:01 AM, Fred. Zwarts wrote:Which does not change the fact that simulating HHH does not >>>>>>>>>>>>> see that the simulated HHH would also abort,
Op 14.feb.2025 om 13:48 schreef olcott:
On 2/14/2025 3:53 AM, Fred. Zwarts wrote:Olcott is again dreaming of a HHH that does not abort. >>>>>>>>>>>>>>> Dreams are no substitute for reasoning.
Op 14.feb.2025 om 01:12 schreef olcott:
On 2/13/2025 8:47 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>> Op 13.feb.2025 om 13:31 schreef olcott: >>>>>>>>>>>>>>>>>>>> On 2/13/2025 3:16 AM, joes wrote:
Am Wed, 12 Feb 2025 22:18:32 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 2:05 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>> Am Tue, 11 Feb 2025 10:19:11 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>> On 2/11/2025 9:23 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 15:38:37 -0600 schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>> On 2/10/2025 2:48 PM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 08:46:21 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
That IS the point. DD does nothing else than call HHH. >>>>>>>>>>>>>>>>>>>>>I reject infinite deflection away from the point. >>>>>>>>>>>>>>>>>>>>>> The absoluteOn 2/10/2025 6:52 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Mon, 10 Feb 2025 06:02:48 -0600 schrieb >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott:
On 2/10/2025 5:16 AM, joes wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Am Sun, 09 Feb 2025 13:54:39 -0600 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schrieb olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 1:33 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 20:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 12:54 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 18:00 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 10:50 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 16:18 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/9/2025 2:13 AM, Fred. Zwarts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 09.feb.2025 om 07:10 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:54 PM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 15:47 schreef >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/8/2025 3:57 AM, Fred. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 08.feb.2025 om 06:53 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 7:27 PM, Richard >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 8:12 PM, olcott >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 5:56 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/25 11:26 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/7/2025 6:20 AM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 10:02 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 8:21 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 5:18 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 1:51 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/25 1:26 PM, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2/6/2025 10:52 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM, Bonita Montero >>>>>>>>>>>>>>>>>>>>>doesn’t halt, it is not a decider. >>>>>>>>>>>>>>>>>>>>>>>> I am not going to ever talk about that. >>>>>>>>>>>>>>>>>>>>>>> Oh goody, you’re never getting anywhere if you >>>>>>>>>>>>>>>>>>>>>>> reject corrections.
The directly executed HHH(DD) always halts >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and returns a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> value as soon as it correctly determines >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its input cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly terminate normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> We were talking about HHH(HHH). If the >>>>>>>>>>>>>>>>>>>>>>>>>>>>> outer HHH halts according >>>>>>>>>>>>>>>>>>>>>>>>>>>>> to spec, so does the inner, because it is >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same. Therefore it >>>>>>>>>>>>>>>>>>>>>>>>>>>>> can’t report „non-halting” and be correct. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> If the inner HHHHHH is supposed to be a decider, i.e. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halt and return the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct value.If this was true then you could point >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> out exactly where HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect.} >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> but he denies it. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> He lacks the ability to accept simple >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts, which >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> he tries to hide with a lot of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> irrelevant words. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is a verified fact that main cannot >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> possibly be correctly >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated by HHH until its normal >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Indeed, which proves that HHH is unable >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to simulate itself >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly.Which proves that HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> make a correct >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision about DD's halting >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour. All other >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> methods (direct execution, >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation by a world class >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator, etc.) show >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that DD halts. But HHH fails to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> see it. Everyone with >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient understanding of >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> programming sees that HHH >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is not correctly programmed >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it aborts one cycle >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> before the simulation would end >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normally. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The execution trace only shows >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete its simulation, because >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH is unable to >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate itself. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It turns out that Olcott does not >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> even understand this >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simple proof that HHH produces >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> false negatives. HHH is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unable to simulate itself up to the >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> normal termination. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, in other words, Olcott denies >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified facts. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HHH generates false negatives, as is >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> verified in >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return HHH(main);
single-mined focus point is that DD correctly >>>>>>>>>>>>>>>>>>>>>> simulated by HHH cannot
possible terminate normally.
Since there is a 5% chance that the treatment I >>>>>>>>>>>>>>>>>>>>>> will have next month
will kill me and this treatment is my only good >>>>>>>>>>>>>>>>>>>>>> chance I will totally
ignore anything that diverges from the point. >>>>>>>>>>>>>>>>>>>>> Ok, I will wait a month then.
Anyone that knows the C language sufficiently well >>>>>>>>>>>>>>>>>>>> knows
that DD correctly simulated by HHH cannot possibly >>>>>>>>>>>>>>>>>>>> terminate normally.
Indeed, which shows the limitation of HHH which makes >>>>>>>>>>>>>>>>>>> that it cannot properly decide about its input, >>>>>>>>>>>>>>>>>>> because it must abort the correct simulation before >>>>>>>>>>>>>>>>>>> it sees that the correct simulation terminates normally. >>>>>>>>>>>>>>>>>>>
The correct simulation is only the one that it sees >>>>>>>>>>>>>>>>>> by definition. it maps ITS INPUT TO THE BEHAVIOR OF >>>>>>>>>>>>>>>>>> THIS INPUT.
If I close my eyes, so that I do not see the accident, >>>>>>>>>>>>>>>>> I cannot claim that the accident did not happen. That >>>>>>>>>>>>>>>>> is the reasoning of a 2 years old child.
HHH(DD) maps the finite string input of DD to the >>>>>>>>>>>>>>>> behavior that it specifies. This behavior does include >>>>>>>>>>>>>>>> DD repeatedly calling HHH(DD)
in recursive simulation that that cannot possibly >>>>>>>>>>>>>>>> terminate normally.
The simulating HHH aborts the simulation, closes its eyes >>>>>>>>>>>>>>> and does not see that the simulated HHH also aborts so >>>>>>>>>>>>>>> that the program terminates normally.
It is only your lack of technical competence that makes it >>>>>>>>>>>>>> seem that
(a) The simulated HHH aborts its simulation
after itself is no longer being simulated.
(b) Either the outermost HHH aborts its simulation >>>>>>>>>>>>>> of none of them do.
The simulated HHH cannot possibly abort because it can't >>>>>>>>>>>> possibly
get to the point where it sees that it needs to abort
because it
is aborted before it gets to this point.
Exactly! So the simulating HHH fails to reach the point where >>>>>>>>>>> the simulated HHH aborts and halts. The simulating misses in >>>>>>>>>>> this way relevant details of the program given in its input. >>>>>>>>>>> That is the reason why it fails. It is unable to see the >>>>>>>>>>> whole input, because it gets stuck in recursive simulation of >>>>>>>>>>> itself.
This is all moot because the executed HHH recognizes this
pattern and correctly reports that its input cannot possibly >>>>>>>>>> terminate normally.
It only reports that the simulation was aborted. Not more, not >>>>>>>>> less.
That you do not understand the term: "terminates normally"
is far less than no rebuttal at all.
So we (Olcott and me) agree that HHH cannot possibly simulate up >>>>>>> to the normal termination of the program described by the finite >>>>>>> string.
Good.
However, Olcott fails to see that it is a failure of HHH to be
unable to simulate a halting program up to the end.
What most everyone fails to understand is that the inability to
accomplish the logically impossible is never any actual sort of
failure.
impossible. He thinks that he can claim that it is possible by
changing the definitions.
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
So, Olcott thinks that by changing the definitions he can create an
algorithm to encode a correct geometric square circle
*I didn't say anything like that*
That you said that did does not seem like any honest mistake.
But it is just as isomorphic to what you said as your "termination
analyzer" is to the Halting Problem.
On 2/17/2025 10:16 PM, Richard Damon wrote:
On 2/17/25 10:54 PM, olcott wrote:
On 2/17/2025 6:51 PM, Richard Damon wrote:
On 2/17/25 3:25 PM, olcott wrote:
On 2/17/2025 2:16 PM, Fred. Zwarts wrote:
Op 17.feb.2025 om 18:11 schreef olcott:
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
So, Olcott thinks that by changing the definitions he can create
an algorithm to encode a correct geometric square circle
*I didn't say anything like that*
That you said that did does not seem like any honest mistake.
But it is just as isomorphic to what you said as your "termination
analyzer" is to the Halting Problem.
THAT IS NOT THE TOPIC OF THE ABOVE REPLY.
Of course it is, YOU claim he is wrong because you didn't say what he
said you implied, but your statement *IS* Isomorphic to it in a sense.
I did not even use the term isomorphic in the above.
I will start trimming the posts much more.
*Stay within the precise context of my exact reply*
The problem of defining the algorithm to encode an actual
square circle can only be correctly rejected as nonsense.
On 2/18/2025 6:25 AM, Richard Damon wrote:Impossible problems, like halting deciders. Asking for one makes no sense
On 2/18/25 6:22 AM, olcott wrote:It is generally the case that problems that are defined to be impossible
And who cares about that.
I am talking about the impossibility of defining an Algorithm to
correctly encode square circles not placing any limit on computation.
DO NOT EVER ACTUALLY LIMIT COMPUTATION.
On 2/18/2025 7:53 AM, joes wrote:Well, only if you unfathomably *wanted* a decider.
Am Tue, 18 Feb 2025 07:29:55 -0600 schrieb olcott:What no one has ever bothered to notice is that impossible problems do
On 2/18/2025 6:25 AM, Richard Damon wrote:Impossible problems, like halting deciders. Asking for one makes no
On 2/18/25 6:22 AM, olcott wrote:It is generally the case that problems that are defined to be
And who cares about that.
I am talking about the impossibility of defining an Algorithm to
correctly encode square circles not placing any limit on
computation.
impossible DO NOT EVER ACTUALLY LIMIT COMPUTATION.
sense the same way that asking for square circles does. Sure, you may
be able to decide on the halting of infinitely many programs, but there
will always be inf. many you cannot, among them everything that calls
the supposed „decider”.
not place any actual real limit on computation.
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 12:04 AM, olcott wrote:
On 2/17/2025 10:16 PM, Richard Damon wrote:
On 2/17/25 10:54 PM, olcott wrote:
On 2/17/2025 6:51 PM, Richard Damon wrote:
On 2/17/25 3:25 PM, olcott wrote:
On 2/17/2025 2:16 PM, Fred. Zwarts wrote:
Op 17.feb.2025 om 18:11 schreef olcott:
On 2/17/2025 9:43 AM, Fred. Zwarts wrote:
Op 17.feb.2025 om 15:06 schreef olcott:
When the problem definition is specify the algorithm
for correctly encoding a correct geometric square circle
then rejecting the original problem definition is the only
correct option.
The inability to correctly encode such as algorithm
places no actual limit on computation.
So, Olcott thinks that by changing the definitions he can create >>>>>>>> an algorithm to encode a correct geometric square circle
*I didn't say anything like that*
That you said that did does not seem like any honest mistake.
But it is just as isomorphic to what you said as your "termination >>>>>> analyzer" is to the Halting Problem.
THAT IS NOT THE TOPIC OF THE ABOVE REPLY.
Of course it is, YOU claim he is wrong because you didn't say what
he said you implied, but your statement *IS* Isomorphic to it in a
sense.
I did not even use the term isomorphic in the above.
I will start trimming the posts much more.
No, you complianed about someone else using it to mock your misuse of
it elsewhere.
The problem is your initial statement was based on erroneous
presumptions, which was being pointed out.
*Stay within the precise context of my exact reply*
If it HAD a percise meaning.
Your problem is you misuse so many words, your statement are often
just nonsense.
The problem of defining the algorithm to encode an actual
square circle can only be correctly rejected as nonsense.
But the arguement is in error if the problem was to draw a square with
the same area as a circle, the classical "Squaring the Circle" problem.
I didn't say anything like that either.
On 2/18/2025 6:25 AM, Richard Damon wrote:
On 2/18/25 6:22 AM, olcott wrote:
I am talking about the impossibility of defining an Algorithm to
correctly encode square circles not placing any limit on computation.
And who cares about that.
It is generally the case that problems that are defined to be impossible
DO NOT EVER ACTUALLY LIMIT COMPUTATION.
On 2/18/2025 10:51 AM, joes wrote:
Am Tue, 18 Feb 2025 10:41:57 -0600 schrieb olcott:
On 2/18/2025 7:53 AM, joes wrote:Well, only if you unfathomably *wanted* a decider.
Am Tue, 18 Feb 2025 07:29:55 -0600 schrieb olcott:What no one has ever bothered to notice is that impossible problems do
On 2/18/2025 6:25 AM, Richard Damon wrote:Impossible problems, like halting deciders. Asking for one makes no
On 2/18/25 6:22 AM, olcott wrote:It is generally the case that problems that are defined to be
And who cares about that.
I am talking about the impossibility of defining an Algorithm to >>>>>>> correctly encode square circles not placing any limit on
computation.
impossible DO NOT EVER ACTUALLY LIMIT COMPUTATION.
sense the same way that asking for square circles does. Sure, you may
be able to decide on the halting of infinitely many programs, but there >>>> will always be inf. many you cannot, among them everything that calls
the supposed „decider”.
i
not place any actual real limit on computation.
Isomorphic to "wanting" a square circle, thus equally ridiculous.
On 2/18/2025 7:53 AM, joes wrote:
Am Tue, 18 Feb 2025 07:29:55 -0600 schrieb olcott:
On 2/18/2025 6:25 AM, Richard Damon wrote:Impossible problems, like halting deciders. Asking for one makes no sense
On 2/18/25 6:22 AM, olcott wrote:It is generally the case that problems that are defined to be impossible >>> DO NOT EVER ACTUALLY LIMIT COMPUTATION.
And who cares about that.
I am talking about the impossibility of defining an Algorithm to
correctly encode square circles not placing any limit on computation. >>>>>
the same way that asking for square circles does. Sure, you may be able
to decide on the halting of infinitely many programs, but there will
always be inf. many you cannot, among them everything that calls the
supposed „decider”.
What no one has ever bothered to notice is that impossible
problems do not place any actual real limit on computation.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 167:26:10 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,533 |