On 10/23/2025 2:06 PM, olcott wrote:<analysis mode="simulation" rules="strict">
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:
On 2025-10-20 16:17:07 +0000, olcott said:
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said:
On 10/19/2025 4:24 AM, Mikko wrote:
On 2025-10-18 13:16:50 +0000, olcott said:
On 10/18/2025 7:16 AM, olcott wrote:
<Input to LLM systems>
Please think this all the way through without making >>>>>>>>>>>>>>>>>>> any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: abort >>>>>>>>>>>>>>>>>>> simulation and return 0.
(b) Simulated input reaches its simulated "return" >>>>>>>>>>>>>>>>>>> statement: return 1.
(c) If HHH must abort its simulation to prevent its >>>>>>>>>>>>>>>>>>> own non- termination
then HHH is correct to abort this simulation and >>>>>>>>>>>>>>>>>>> return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider to >>>>>>>>>>>>>>>>>> report
on anything besides the behavior that its input actually >>>>>>>>>>>>>>>>>> specifies this is just like requiring a silk purse be >>>>>>>>>>>>>>>>>> made
from a sow's ear.
The way halting problem is usally presented the input >>>>>>>>>>>>>>>>> to the
problem is a Truing machine
The input to the problem is never ever a Turing
machine it is always a finite string generally
assumed to be a machine description.
The input to the problem as usually presented is a pair of a >>>>>>>>>>>>> Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>> description and never an actual Turing machine.
As the problem is presented in Wikipedia the input to the proble >>>>>>>>>>> is a program and an input to it. Both can be regareded as finite >>>>>>>>>>> strings.
The behavior of the caller of HHH(DD) is not encoded in its >>>>>>>>>> input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error.
No, it does not. Nothing in the problem statement "Present a >>>>>>>>> method
to determine whether a given program halts or runs forwever when >>>>>>>>> started with a given input to that program" says that the
behaviour
of the caller of HHH(DD) is not encoded to in the input to HHH. >>>>>>>>> It merely requires that the required method produces the correct >>>>>>>>> answer for any program and any input.
Sure and equally the pure mental object of a Turing
machine is limited in this same sort of way that it
cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report on the >>>>>>> halt status of the machine described by the input:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
described machine, including whether it halts when executed >>>>>>> directly.;
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly agreed with >>>>> the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:directly.
And it is a semantic tautology that a finite string description >>>>> of a
Turing machine is stipulated to specify all semantic properties >>>>> of the
described machine, including whether it halts when executed
;
Yes that is all correct
This means you agree that the finite string input to HHH(DD), which >>>>> is the description of machine DD and therefore specifies all
semantic properties of that machine, specifies halting behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior
*No stupid exactly the opposite of that*
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
And because HHH aborts,
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:<analysis mode="simulation" rules="strict">
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:
On 2025-10-20 16:17:07 +0000, olcott said:
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said:
On 10/19/2025 4:24 AM, Mikko wrote:
On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote:
<Input to LLM systems>
Please think this all the way through without making >>>>>>>>>>>>>>>>>>>> any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: >>>>>>>>>>>>>>>>>>>> abort simulation and return 0.
(b) Simulated input reaches its simulated "return" >>>>>>>>>>>>>>>>>>>> statement: return 1.
(c) If HHH must abort its simulation to prevent its >>>>>>>>>>>>>>>>>>>> own non- termination
then HHH is correct to abort this simulation >>>>>>>>>>>>>>>>>>>> and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider to >>>>>>>>>>>>>>>>>>> report
on anything besides the behavior that its input actually >>>>>>>>>>>>>>>>>>> specifies this is just like requiring a silk purse be >>>>>>>>>>>>>>>>>>> made
from a sow's ear.
The way halting problem is usally presented the input >>>>>>>>>>>>>>>>>> to the
problem is a Truing machine
The input to the problem is never ever a Turing
machine it is always a finite string generally
assumed to be a machine description.
The input to the problem as usually presented is a pair of a >>>>>>>>>>>>>> Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>> description and never an actual Turing machine.
As the problem is presented in Wikipedia the input to the >>>>>>>>>>>> proble
is a program and an input to it. Both can be regareded as >>>>>>>>>>>> finite
strings.
The behavior of the caller of HHH(DD) is not encoded in its >>>>>>>>>>> input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error.
No, it does not. Nothing in the problem statement "Present a >>>>>>>>>> method
to determine whether a given program halts or runs forwever when >>>>>>>>>> started with a given input to that program" says that the >>>>>>>>>> behaviour
of the caller of HHH(DD) is not encoded to in the input to HHH. >>>>>>>>>> It merely requires that the required method produces the correct >>>>>>>>>> answer for any program and any input.
Sure and equally the pure mental object of a Turing
machine is limited in this same sort of way that it
cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report on the >>>>>>>> halt status of the machine described by the input:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
described machine, including whether it halts when executed >>>>>>>> directly.;
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly agreed
with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
directly.described machine, including whether it halts when executed
;
Yes that is all correct
This means you agree that the finite string input to HHH(DD),
which is the description of machine DD and therefore specifies all >>>>>> semantic properties of that machine, specifies halting behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior
*No stupid exactly the opposite of that*
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
And because HHH aborts,
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
On 10/23/2025 2:17 PM, olcott wrote:
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:<analysis mode="simulation" rules="strict">
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:No, it does not. Nothing in the problem statement "Present a >>>>>>>>>>> method
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:
On 2025-10-20 16:17:07 +0000, olcott said:
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said:
On 10/19/2025 4:24 AM, Mikko wrote:
On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote:
<Input to LLM systems>
Please think this all the way through without >>>>>>>>>>>>>>>>>>>>> making any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: >>>>>>>>>>>>>>>>>>>>> abort simulation and return 0.
(b) Simulated input reaches its simulated "return" >>>>>>>>>>>>>>>>>>>>> statement: return 1.
(c) If HHH must abort its simulation to prevent its >>>>>>>>>>>>>>>>>>>>> own non- termination
then HHH is correct to abort this simulation >>>>>>>>>>>>>>>>>>>>> and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider to >>>>>>>>>>>>>>>>>>>> report
on anything besides the behavior that its input >>>>>>>>>>>>>>>>>>>> actually
specifies this is just like requiring a silk purse >>>>>>>>>>>>>>>>>>>> be made
from a sow's ear.
The way halting problem is usally presented the input >>>>>>>>>>>>>>>>>>> to the
problem is a Truing machine
The input to the problem is never ever a Turing >>>>>>>>>>>>>>>> machine it is always a finite string generally >>>>>>>>>>>>>>>> assumed to be a machine description.
The input to the problem as usually presented is a pair of a >>>>>>>>>>>>>>> Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>>> description and never an actual Turing machine.
As the problem is presented in Wikipedia the input to the >>>>>>>>>>>>> proble
is a program and an input to it. Both can be regareded as >>>>>>>>>>>>> finite
strings.
The behavior of the caller of HHH(DD) is not encoded in its >>>>>>>>>>>> input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error. >>>>>>>>>>>
to determine whether a given program halts or runs forwever when >>>>>>>>>>> started with a given input to that program" says that the >>>>>>>>>>> behaviour
of the caller of HHH(DD) is not encoded to in the input to HHH. >>>>>>>>>>> It merely requires that the required method produces the correct >>>>>>>>>>> answer for any program and any input.
Sure and equally the pure mental object of a Turing
machine is limited in this same sort of way that it
cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report on >>>>>>>>> the halt status of the machine described by the input:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
described machine, including whether it halts when executed >>>>>>>>> directly.;
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly agreed
with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
described machine, including whether it halts when executed >>>>>>> directly.;
Yes that is all correct
This means you agree that the finite string input to HHH(DD),
which is the description of machine DD and therefore specifies
all semantic properties of that machine, specifies halting behavior. >>>>>>>
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior
*No stupid exactly the opposite of that*
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
And because HHH aborts,
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
False.
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is proven
true by the meaning of the words.
On 10/23/2025 1:31 PM, dbush wrote:
On 10/23/2025 2:17 PM, olcott wrote:
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:No, it does not. Nothing in the problem statement "Present a >>>>>>>>>>>> method
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:
On 2025-10-20 16:17:07 +0000, olcott said:
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 10/19/2025 4:24 AM, Mikko wrote:
On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>> <Input to LLM systems>
Please think this all the way through without >>>>>>>>>>>>>>>>>>>>>> making any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: >>>>>>>>>>>>>>>>>>>>>> abort simulation and return 0.
(b) Simulated input reaches its simulated "return" >>>>>>>>>>>>>>>>>>>>>> statement: return 1.
(c) If HHH must abort its simulation to prevent >>>>>>>>>>>>>>>>>>>>>> its own non- termination
then HHH is correct to abort this simulation >>>>>>>>>>>>>>>>>>>>>> and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider to >>>>>>>>>>>>>>>>>>>>> report
on anything besides the behavior that its input >>>>>>>>>>>>>>>>>>>>> actually
specifies this is just like requiring a silk purse >>>>>>>>>>>>>>>>>>>>> be made
from a sow's ear.
The way halting problem is usally presented the >>>>>>>>>>>>>>>>>>>> input to the
problem is a Truing machine
The input to the problem is never ever a Turing >>>>>>>>>>>>>>>>> machine it is always a finite string generally >>>>>>>>>>>>>>>>> assumed to be a machine description.
The input to the problem as usually presented is a pair >>>>>>>>>>>>>>>> of a
Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>>>> description and never an actual Turing machine.
As the problem is presented in Wikipedia the input to the >>>>>>>>>>>>>> proble
is a program and an input to it. Both can be regareded as >>>>>>>>>>>>>> finite
strings.
The behavior of the caller of HHH(DD) is not encoded in its >>>>>>>>>>>>> input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error. >>>>>>>>>>>>
to determine whether a given program halts or runs forwever >>>>>>>>>>>> when
started with a given input to that program" says that the >>>>>>>>>>>> behaviour
of the caller of HHH(DD) is not encoded to in the input to HHH. >>>>>>>>>>>> It merely requires that the required method produces the >>>>>>>>>>>> correct
answer for any program and any input.
Sure and equally the pure mental object of a Turing
machine is limited in this same sort of way that it
cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report on >>>>>>>>>> the halt status of the machine described by the input:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
executed directly.Turing machine is stipulated to specify all semantic >>>>>>>>>> properties of the
described machine, including whether it halts when
;
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly agreed >>>>>>>> with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
described machine, including whether it halts when executed >>>>>>>> directly.;
Yes that is all correct
This means you agree that the finite string input to HHH(DD), >>>>>>>> which is the description of machine DD and therefore specifies >>>>>>>> all semantic properties of that machine, specifies halting
behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior
*No stupid exactly the opposite of that*
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
And because HHH aborts, DD is *NOT* simulated by HHH according to the semantics of its specification language.
Therefore there is no basis to judge the behavior.
<analysis mode="simulation" rules="strict">
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
False.
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is proven
true by the meaning of the words.
Do you have brain damage that prevents you
from paying complete attention?
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
On 10/23/2025 2:40 PM, olcott wrote:
On 10/23/2025 1:31 PM, dbush wrote:
On 10/23/2025 2:17 PM, olcott wrote:
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:*No stupid exactly the opposite of that*
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:No, it does not. Nothing in the problem statement "Present >>>>>>>>>>>>> a method
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:As the problem is presented in Wikipedia the input to the >>>>>>>>>>>>>>> proble
On 2025-10-20 16:17:07 +0000, olcott said:
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>
On 10/19/2025 4:24 AM, Mikko wrote:
On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> <Input to LLM systems>
Please think this all the way through without >>>>>>>>>>>>>>>>>>>>>>> making any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: >>>>>>>>>>>>>>>>>>>>>>> abort simulation and return 0.
(b) Simulated input reaches its simulated >>>>>>>>>>>>>>>>>>>>>>> "return" statement: return 1.
(c) If HHH must abort its simulation to prevent >>>>>>>>>>>>>>>>>>>>>>> its own non- termination
then HHH is correct to abort this simulation >>>>>>>>>>>>>>>>>>>>>>> and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider >>>>>>>>>>>>>>>>>>>>>> to report
on anything besides the behavior that its input >>>>>>>>>>>>>>>>>>>>>> actually
specifies this is just like requiring a silk purse >>>>>>>>>>>>>>>>>>>>>> be made
from a sow's ear.
The way halting problem is usally presented the >>>>>>>>>>>>>>>>>>>>> input to the
problem is a Truing machine
The input to the problem is never ever a Turing >>>>>>>>>>>>>>>>>> machine it is always a finite string generally >>>>>>>>>>>>>>>>>> assumed to be a machine description.
The input to the problem as usually presented is a pair >>>>>>>>>>>>>>>>> of a
Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>>>>> description and never an actual Turing machine. >>>>>>>>>>>>>>>
is a program and an input to it. Both can be regareded as >>>>>>>>>>>>>>> finite
strings.
The behavior of the caller of HHH(DD) is not encoded in >>>>>>>>>>>>>> its input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error. >>>>>>>>>>>>>
to determine whether a given program halts or runs forwever >>>>>>>>>>>>> when
started with a given input to that program" says that the >>>>>>>>>>>>> behaviour
of the caller of HHH(DD) is not encoded to in the input to >>>>>>>>>>>>> HHH.
It merely requires that the required method produces the >>>>>>>>>>>>> correct
answer for any program and any input.
Sure and equally the pure mental object of a Turing
machine is limited in this same sort of way that it
cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report on >>>>>>>>>>> the halt status of the machine described by the input:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:
And it is a semantic tautology that a finite string >>>>>>>>>>> description of a;
Turing machine is stipulated to specify all semantic >>>>>>>>>>> properties of the
described machine, including whether it halts when >>>>>>>>>>> executed directly.
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly agreed >>>>>>>>> with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
properties of theTuring machine is stipulated to specify all semantic
described machine, including whether it halts when executed >>>>>>>>> directly.;
Yes that is all correct
This means you agree that the finite string input to HHH(DD), >>>>>>>>> which is the description of machine DD and therefore specifies >>>>>>>>> all semantic properties of that machine, specifies halting
behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior >>>>>>
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
The above point
And because HHH aborts, DD is *NOT* simulated by HHH according to
the semantics of its specification language.
Therefore there is no basis to judge the behavior.
Was refuted above
<analysis mode="simulation" rules="strict">
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
False.
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is proven
true by the meaning of the words.
Do you have brain damage that prevents you
from paying complete attention?
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
Repeat of previously refuted point (see above).
On 10/23/2025 1:48 PM, dbush wrote:
On 10/23/2025 2:40 PM, olcott wrote:
On 10/23/2025 1:31 PM, dbush wrote:
On 10/23/2025 2:17 PM, olcott wrote:
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:*No stupid exactly the opposite of that*
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:No, it does not. Nothing in the problem statement "Present >>>>>>>>>>>>>> a method
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:As the problem is presented in Wikipedia the input to >>>>>>>>>>>>>>>> the proble
On 2025-10-20 16:17:07 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 10/19/2025 4:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>> <Input to LLM systems>
Please think this all the way through without >>>>>>>>>>>>>>>>>>>>>>>> making any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: >>>>>>>>>>>>>>>>>>>>>>>> abort simulation and return 0. >>>>>>>>>>>>>>>>>>>>>>>> (b) Simulated input reaches its simulated >>>>>>>>>>>>>>>>>>>>>>>> "return" statement: return 1.
(c) If HHH must abort its simulation to prevent >>>>>>>>>>>>>>>>>>>>>>>> its own non- termination
then HHH is correct to abort this >>>>>>>>>>>>>>>>>>>>>>>> simulation and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider >>>>>>>>>>>>>>>>>>>>>>> to report
on anything besides the behavior that its input >>>>>>>>>>>>>>>>>>>>>>> actually
specifies this is just like requiring a silk >>>>>>>>>>>>>>>>>>>>>>> purse be made
from a sow's ear.
The way halting problem is usally presented the >>>>>>>>>>>>>>>>>>>>>> input to the
problem is a Truing machine
The input to the problem is never ever a Turing >>>>>>>>>>>>>>>>>>> machine it is always a finite string generally >>>>>>>>>>>>>>>>>>> assumed to be a machine description.
The input to the problem as usually presented is a >>>>>>>>>>>>>>>>>> pair of a
Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>>>>>> description and never an actual Turing machine. >>>>>>>>>>>>>>>>
is a program and an input to it. Both can be regareded >>>>>>>>>>>>>>>> as finite
strings.
The behavior of the caller of HHH(DD) is not encoded in >>>>>>>>>>>>>>> its input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error. >>>>>>>>>>>>>>
to determine whether a given program halts or runs >>>>>>>>>>>>>> forwever when
started with a given input to that program" says that the >>>>>>>>>>>>>> behaviour
of the caller of HHH(DD) is not encoded to in the input to >>>>>>>>>>>>>> HHH.
It merely requires that the required method produces the >>>>>>>>>>>>>> correct
answer for any program and any input.
Sure and equally the pure mental object of a Turing
machine is limited in this same sort of way that it
cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report on >>>>>>>>>>>> the halt status of the machine described by the input: >>>>>>>>>>>>
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:
And it is a semantic tautology that a finite string >>>>>>>>>>>> description of a;
Turing machine is stipulated to specify all semantic >>>>>>>>>>>> properties of the
described machine, including whether it halts when >>>>>>>>>>>> executed directly.
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly agreed >>>>>>>>>> with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:description of a
And it is a semantic tautology that a finite string
executed directly.Turing machine is stipulated to specify all semantic >>>>>>>>>> properties of the
described machine, including whether it halts when
;
Yes that is all correct
This means you agree that the finite string input to HHH(DD), >>>>>>>>>> which is the description of machine DD and therefore specifies >>>>>>>>>> all semantic properties of that machine, specifies halting >>>>>>>>>> behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior >>>>>>>
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
The above point
And because HHH aborts, DD is *NOT* simulated by HHH according to >>>>>> the semantics of its specification language.
Therefore there is no basis to judge the behavior.
Was refuted above
<analysis mode="simulation" rules="strict">
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
False.
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is proven >>>> true by the meaning of the words.
Do you have brain damage that prevents you
from paying complete attention?
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
Repeat of previously refuted point (see above).
No one has ever refuted me you lying Jackass.
This counts as less than no rebuttal and is therefore you admission that the point it was posted in response to:
----------------------------------
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is proven true by the meaning of the words.
----------------------------------
As well as the original refutation of that point:
----------------------------------
And because HHH aborts, DD is *NOT* simulated by HHH according to the semantics of its specification language.
Therefore there is no basis to judge the behavior.
----------------------------------
Are both *CORRECT*.
On 10/23/2025 2:55 PM, olcott wrote:
On 10/23/2025 1:48 PM, dbush wrote:
On 10/23/2025 2:40 PM, olcott wrote:
On 10/23/2025 1:31 PM, dbush wrote:
On 10/23/2025 2:17 PM, olcott wrote:
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:*No stupid exactly the opposite of that*
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:No, it does not. Nothing in the problem statement >>>>>>>>>>>>>>> "Present a method
On 2025-10-21 15:04:58 +0000, olcott said:
On 10/21/2025 3:45 AM, Mikko wrote:As the problem is presented in Wikipedia the input to >>>>>>>>>>>>>>>>> the proble
On 2025-10-20 16:17:07 +0000, olcott said: >>>>>>>>>>>>>>>>>>>
On 10/20/2025 3:42 AM, Mikko wrote:
On 2025-10-19 16:21:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>
On 10/19/2025 4:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>> On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> <Input to LLM systems>
Please think this all the way through without >>>>>>>>>>>>>>>>>>>>>>>>> making any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until:
(a) Detects a non-terminating behavior pattern: >>>>>>>>>>>>>>>>>>>>>>>>> abort simulation and return 0. >>>>>>>>>>>>>>>>>>>>>>>>> (b) Simulated input reaches its simulated >>>>>>>>>>>>>>>>>>>>>>>>> "return" statement: return 1. >>>>>>>>>>>>>>>>>>>>>>>>> (c) If HHH must abort its simulation to prevent >>>>>>>>>>>>>>>>>>>>>>>>> its own non- termination
then HHH is correct to abort this >>>>>>>>>>>>>>>>>>>>>>>>> simulation and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt decider >>>>>>>>>>>>>>>>>>>>>>>> to report
on anything besides the behavior that its input >>>>>>>>>>>>>>>>>>>>>>>> actually
specifies this is just like requiring a silk >>>>>>>>>>>>>>>>>>>>>>>> purse be made
from a sow's ear.
The way halting problem is usally presented the >>>>>>>>>>>>>>>>>>>>>>> input to the
problem is a Truing machine
The input to the problem is never ever a Turing >>>>>>>>>>>>>>>>>>>> machine it is always a finite string generally >>>>>>>>>>>>>>>>>>>> assumed to be a machine description.
The input to the problem as usually presented is a >>>>>>>>>>>>>>>>>>> pair of a
Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>>>>>>> description and never an actual Turing machine. >>>>>>>>>>>>>>>>>
is a program and an input to it. Both can be regareded >>>>>>>>>>>>>>>>> as finite
strings.
The behavior of the caller of HHH(DD) is not encoded in >>>>>>>>>>>>>>>> its input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error. >>>>>>>>>>>>>>>
to determine whether a given program halts or runs >>>>>>>>>>>>>>> forwever when
started with a given input to that program" says that the >>>>>>>>>>>>>>> behaviour
of the caller of HHH(DD) is not encoded to in the input >>>>>>>>>>>>>>> to HHH.
It merely requires that the required method produces the >>>>>>>>>>>>>>> correct
answer for any program and any input.
Sure and equally the pure mental object of a Turing >>>>>>>>>>>>>> machine is limited in this same sort of way that it >>>>>>>>>>>>>> cannot bake a birthday cake.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state >>>>>>>>>>>>>> or reject state on the basis that this input finite >>>>>>>>>>>>>> string specifies a semantic or syntactic property.
And you agreed that this means they are allowed to report >>>>>>>>>>>>> on the halt status of the machine described by the input: >>>>>>>>>>>>>
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:
And it is a semantic tautology that a finite string >>>>>>>>>>>>> description of a;
Turing machine is stipulated to specify all semantic >>>>>>>>>>>>> properties of the
described machine, including whether it halts when >>>>>>>>>>>>> executed directly.
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly >>>>>>>>>>> agreed with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:
And it is a semantic tautology that a finite string >>>>>>>>>>> description of a;
Turing machine is stipulated to specify all semantic >>>>>>>>>>> properties of the
described machine, including whether it halts when >>>>>>>>>>> executed directly.
Yes that is all correct
This means you agree that the finite string input to HHH(DD), >>>>>>>>>>> which is the description of machine DD and therefore
specifies all semantic properties of that machine, specifies >>>>>>>>>>> halting behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior >>>>>>>>
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
The above point
And because HHH aborts, DD is *NOT* simulated by HHH according to >>>>>>> the semantics of its specification language.
Therefore there is no basis to judge the behavior.
Was refuted above
<analysis mode="simulation" rules="strict">
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
False.
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is
proven true by the meaning of the words.
Do you have brain damage that prevents you
from paying complete attention?
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
Repeat of previously refuted point (see above).
No one has ever refuted me you lying Jackass.
Read the whole post, *then* respond.
This counts as less than no rebuttal and is therefore you admission
that the point it was posted in response to:
----------------------------------
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is proven
true by the meaning of the words.
----------------------------------
As well as the original refutation of that point:
----------------------------------
And because HHH aborts, DD is *NOT* simulated by HHH according to the
semantics of its specification language.
Therefore there is no basis to judge the behavior.
----------------------------------
Are both *CORRECT*.
On 10/23/2025 1:59 PM, dbush wrote:
On 10/23/2025 2:55 PM, olcott wrote:
On 10/23/2025 1:48 PM, dbush wrote:
On 10/23/2025 2:40 PM, olcott wrote:
On 10/23/2025 1:31 PM, dbush wrote:
On 10/23/2025 2:17 PM, olcott wrote:
On 10/23/2025 1:09 PM, dbush wrote:
On 10/23/2025 2:06 PM, olcott wrote:
On 10/23/2025 1:00 PM, dbush wrote:
On 10/23/2025 1:58 PM, olcott wrote:*No stupid exactly the opposite of that*
On 10/23/2025 12:03 PM, dbush wrote:
On 10/23/2025 12:49 PM, olcott wrote:That is a perfectly correct statement of the
On 10/23/2025 10:48 AM, dbush wrote:
On 10/23/2025 11:46 AM, olcott wrote:
On 10/23/2025 4:15 AM, Mikko wrote:And you agreed that this means they are allowed to report >>>>>>>>>>>>>> on the halt status of the machine described by the input: >>>>>>>>>>>>>>
On 2025-10-22 12:35:14 +0000, olcott said:
On 10/22/2025 4:07 AM, Mikko wrote:No, it does not. Nothing in the problem statement >>>>>>>>>>>>>>>> "Present a method
On 2025-10-21 15:04:58 +0000, olcott said: >>>>>>>>>>>>>>>>>>
On 10/21/2025 3:45 AM, Mikko wrote:As the problem is presented in Wikipedia the input to >>>>>>>>>>>>>>>>>> the proble
On 2025-10-20 16:17:07 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>
On 10/20/2025 3:42 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>> On 2025-10-19 16:21:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>
On 10/19/2025 4:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 2025-10-18 13:16:50 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>
On 10/18/2025 7:16 AM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> <Input to LLM systems>
Please think this all the way through without >>>>>>>>>>>>>>>>>>>>>>>>>> making any guesses
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>>>>>>>>>> simulates its input until: >>>>>>>>>>>>>>>>>>>>>>>>>> (a) Detects a non-terminating behavior >>>>>>>>>>>>>>>>>>>>>>>>>> pattern: abort simulation and return 0. >>>>>>>>>>>>>>>>>>>>>>>>>> (b) Simulated input reaches its simulated >>>>>>>>>>>>>>>>>>>>>>>>>> "return" statement: return 1. >>>>>>>>>>>>>>>>>>>>>>>>>> (c) If HHH must abort its simulation to >>>>>>>>>>>>>>>>>>>>>>>>>> prevent its own non- termination >>>>>>>>>>>>>>>>>>>>>>>>>> then HHH is correct to abort this >>>>>>>>>>>>>>>>>>>>>>>>>> simulation and return 0.
typedef int (*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);
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>>>>>>>>>> </Input to LLM systems>
When the halting problem requires a halt >>>>>>>>>>>>>>>>>>>>>>>>> decider to report
on anything besides the behavior that its input >>>>>>>>>>>>>>>>>>>>>>>>> actually
specifies this is just like requiring a silk >>>>>>>>>>>>>>>>>>>>>>>>> purse be made
from a sow's ear.
The way halting problem is usally presented the >>>>>>>>>>>>>>>>>>>>>>>> input to the
problem is a Truing machine
The input to the problem is never ever a Turing >>>>>>>>>>>>>>>>>>>>> machine it is always a finite string generally >>>>>>>>>>>>>>>>>>>>> assumed to be a machine description.
The input to the problem as usually presented is a >>>>>>>>>>>>>>>>>>>> pair of a
Turing machine and an input to it.
Wrong again. It is always a finite string Turing Machine >>>>>>>>>>>>>>>>>>> description and never an actual Turing machine. >>>>>>>>>>>>>>>>>>
is a program and an input to it. Both can be regareded >>>>>>>>>>>>>>>>>> as finite
strings.
The behavior of the caller of HHH(DD) is not encoded in >>>>>>>>>>>>>>>>> its input.
HHH has no way to tell who its caller is.
This is what makes the halting problem a category error. >>>>>>>>>>>>>>>>
to determine whether a given program halts or runs >>>>>>>>>>>>>>>> forwever when
started with a given input to that program" says that >>>>>>>>>>>>>>>> the behaviour
of the caller of HHH(DD) is not encoded to in the input >>>>>>>>>>>>>>>> to HHH.
It merely requires that the required method produces the >>>>>>>>>>>>>>>> correct
answer for any program and any input.
Sure and equally the pure mental object of a Turing >>>>>>>>>>>>>>> machine is limited in this same sort of way that it >>>>>>>>>>>>>>> cannot bake a birthday cake.
Turing machine deciders only compute the mapping >>>>>>>>>>>>>>> from their finite string inputs to an accept state >>>>>>>>>>>>>>> or reject state on the basis that this input finite >>>>>>>>>>>>>>> string specifies a semantic or syntactic property. >>>>>>>>>>>>>>
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:
And it is a semantic tautology that a finite string >>>>>>>>>>>>>> description of a;
Turing machine is stipulated to specify all semantic >>>>>>>>>>>>>> properties of the
described machine, including whether it halts when >>>>>>>>>>>>>> executed directly.
Yes that is all correct
That is all a correct statement of the false
assumption that derives the category error.
Turing machine deciders only compute the mapping
from their finite string inputs to an accept state
or reject state on the basis that this input finite
string specifies a semantic or syntactic property.
Repeat of previously refuted point where you explicitly >>>>>>>>>>>> agreed with the refutation:
On 10/20/2025 11:51 PM, olcott wrote:
On 10/20/2025 10:45 PM, dbush wrote:
And it is a semantic tautology that a finite string >>>>>>>>>>>> description of a;
Turing machine is stipulated to specify all semantic >>>>>>>>>>>> properties of the
described machine, including whether it halts when >>>>>>>>>>>> executed directly.
Yes that is all correct
This means you agree that the finite string input to
HHH(DD), which is the description of machine DD and
therefore specifies all semantic properties of that machine, >>>>>>>>>>>> specifies halting behavior.
halting problems false assumption
So you agree that the input to HHH(DD) specifies halting behavior >>>>>>>>>
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
The above point
And because HHH aborts, DD is *NOT* simulated by HHH according >>>>>>>> to the semantics of its specification language.
Therefore there is no basis to judge the behavior.
Was refuted above
<analysis mode="simulation" rules="strict">
- You must simulate the input **exactly as written**,
step by step, without any external reasoning,
assumptions, or guesses.
- **Do not analyze, infer, or speculate**; only describe
what the simulation observes in execution.
- Report only the behavior that occurs in the simulation.
- Always follow the priority rules exactly:
1. (a) Detect non-terminating behavior → abort
simulation and return 0.
2. (b) Return statement reached → return 1.
3. (c) Neither (a) nor (b) → return -1.
- Do not include any commentary about halting
problem, contradictions, or theoretical reasoning.
- All output must be in terms of simulation observations only.
</analysis>
and it is verified that it did this by meeting
criteria (a) then every LLM system agrees that
HHH is correct.
False.
1) DD halts so there is no non-terminating behavior to detect.
2) An aborted simulation is an incorrect simulation. This is
proven true by the meaning of the words.
Do you have brain damage that prevents you
from paying complete attention?
The behavior of DD simulated by HHH according to
the semantics of its specification language C, x86,
Turing Machine description, is the ultimate judge
of the behavior
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
*that the input* (not any damn thing else)
Specifies.
Repeat of previously refuted point (see above).
No one has ever refuted me you lying Jackass.
Read the whole post, *then* respond.
This counts as less than no rebuttal and is therefore you admission
that the point it was posted in response to:
----------------------------------
1) DD halts so there is no non-terminating behavior to detect.
If you weren't so stupid you would
have noticed that I have proved this
does not make one damn difference
fifty times now.
The halt decider
is only supposed to report
on the behavior that its input specifies.
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
REPORTS ON THE BEHAVIOR THAT ITS INPUT SPECIFIES
2) An aborted simulation is an incorrect simulation. This is proven >>>> true by the meaning of the words.
----------------------------------
As well as the original refutation of that point:
----------------------------------
And because HHH aborts, DD is *NOT* simulated by HHH according to
the semantics of its specification language.
Therefore there is no basis to judge the behavior.
----------------------------------
Are both *CORRECT*.
| Sysop: | DaiTengu |
|---|---|
| Location: | Appleton, WI |
| Users: | 1,076 |
| Nodes: | 10 (1 / 9) |
| Uptime: | 28:56:34 |
| Calls: | 13,804 |
| Calls today: | 1 |
| Files: | 186,990 |
| D/L today: |
300 files (66,892K bytes) |
| Messages: | 2,441,602 |