On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt >>>>>>>> decider.
If it returns 'no' it is not a halt decider. If it returns
anyting else
it is not a halt decider. If it does not return it is not a halt >>>>>>>> decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many
steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences
inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
The essential nature of Turing machine halt deciders
requires them to report on their inputs.
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:Within the premise that HHH did simulate that many
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider.
If it returns 'no' it is not a halt decider. If it returns anyting else
it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps. >>>
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences
inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>> anyting else
it is not a halt decider. If it does not return it is not a >>>>>>>>>> halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many
steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences
inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise
is uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
To understand that I really did this requires understanding
all of the steps.
One of these steps is understanding that N steps of DD are
correctly simulated by HHH.
If you are not interested in that step then you are not
interested in truth, only rebuttal.
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:Within the premise that HHH did simulate that many
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider.
If it returns 'no' it is not a halt decider. If it returns anyting else
it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps. >>>>>
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences
inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise
is uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:*To see my proof*
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:If N = googolplex ^ googolplex DD correctly simulated by HHH >>>>>>>>> never reached its own simulated "return" statement final halt >>>>>>>>> state.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>> anyting else it is not a halt decider. If it does not return >>>>>>>>>>>> it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the input to >>>>>>>>>>> HHH(DD) as measured by the correct emulation of N steps of DD >>>>>>>>>>> cannot possibly reach its own emulated "return" statement >>>>>>>>>>> final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex then HHH never simulated that many >>>>>>>> steps.
Within the premise that HHH did simulate that many steps DD still >>>>>>> did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the semantics of the
x86 language can possibly reach its own "ret" instruction final halt >>>>> state is the only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise is
uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting problem
proof because one is only interested in rebuttal and not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some extent
but you have never provided that and there is no reason to expect you
ever will.
The proof is not refuted by talking about something else and pretending
it is not the same. The proof is only refuted by identifying a step
that is not a premise and is not an axiom and does not follow from
earlier steps.
Even if someone could find an error is a proof that would not be very
interesting as long as the conclusion remains proven by different
proofs.
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory of computation. All deciders must only compute the mapping from their finite string input. Anything that is not a finite string input is outside of the scope of
any decider.
M.H applied to ⟨M⟩ ⟨M⟩ does correctly report on the behavior ofits
actual input: M applied to ⟨M⟩ is not an actual input to M.H.halt
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.∞
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qn
*Repeats until aborted proving non-halting*
(a) M copies its input ⟨M⟩
(b) M invokes M.H ⟨M⟩ ⟨M⟩
(c) M.H simulates ⟨M⟩ ⟨M⟩
then M.H ⟨M⟩ ⟨M⟩ transitions to M.qn causing M applied to ⟨M⟩
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>> anyting else
it is not a halt decider. If it does not return it is not a >>>>>>>>>>>> halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that
many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise
is uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some
extent but you have never provided that and there is no reason
to expect you ever will.
The proof is not refuted by talking about something else and
pretending it is not the same. The proof is only refuted by
identifying a step that is not a premise and is not an axiom
and does not follow from earlier steps.
Even if someone could find an error is a proof that would not be
very interesting as long as the conclusion remains proven by
different proofs.
*To see my proof*
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory
of computation. All deciders must only compute the
mapping from their finite string input. Anything that
is not a finite string input is outside of the scope
of any decider.
M.H applied to ⟨M⟩ ⟨M⟩ does correctly report on
the behavior of its actual input: M applied to ⟨M⟩
is not an actual input to M.H.
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.∞
M.q0 ⟨M⟩ ⊢* M.H ⟨M⟩ ⟨M⟩ ⊢* M.qn
*Repeats until aborted proving non-halting*
(a) M copies its input ⟨M⟩
(b) M invokes M.H ⟨M⟩ ⟨M⟩
(c) M.H simulates ⟨M⟩ ⟨M⟩
then M.H ⟨M⟩ ⟨M⟩ transitions to M.qn causing M
applied to ⟨M⟩ halt
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider.
If it returns 'no' it is not a halt decider. If it returns anyting else
it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation
of N steps of DD cannot possibly reach its own emulated
"return" statement final halt state.
It can if N is twice the number of steps emulated by HHH.
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement
final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise
is uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some
extent but you have never provided that and there is no reason
to expect you ever will.
The proof is not refuted by talking about something else and
pretending it is not the same. The proof is only refuted by
identifying a step that is not a premise and is not an axiom
and does not follow from earlier steps.
Even if someone could find an error is a proof that would not be
very interesting as long as the conclusion remains proven by
different proofs.
*To see my proof*
*You must carefully study ALL the words*
On Thu, 14 Aug 2025 12:22:24 -0500, olcott wrote:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:*To see my proof*
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:If N = googolplex ^ googolplex DD correctly simulated by HHH >>>>>>>>>> never reached its own simulated "return" statement final halt >>>>>>>>>> state.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>>> anyting else it is not a halt decider. If it does not return >>>>>>>>>>>>> it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the input to >>>>>>>>>>>> HHH(DD) as measured by the correct emulation of N steps of DD >>>>>>>>>>>> cannot possibly reach its own emulated "return" statement >>>>>>>>>>>> final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>
If N = googolplex ^ googolplex then HHH never simulated that many >>>>>>>>> steps.
Within the premise that HHH did simulate that many steps DD still >>>>>>>> did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the semantics of the >>>>>> x86 language can possibly reach its own "ret" instruction final halt >>>>>> state is the only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise is
uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting problem
proof because one is only interested in rebuttal and not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some extent
but you have never provided that and there is no reason to expect you
ever will.
The proof is not refuted by talking about something else and pretending
it is not the same. The proof is only refuted by identifying a step
that is not a premise and is not an axiom and does not follow from
earlier steps.
Even if someone could find an error is a proof that would not be very
interesting as long as the conclusion remains proven by different
proofs.
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory of computation. All
deciders must only compute the mapping from their finite string input.
Anything that is not a finite string input is outside of the scope of
any decider.
But a *description* of DD is a finite string.
On 8/15/2025 4:04 AM, Mikko wrote:
On 2025-08-14 17:58:49 +0000, Mr Flibble said:
On Thu, 14 Aug 2025 12:22:24 -0500, olcott wrote:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:*To see my proof*
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:If N = googolplex ^ googolplex DD correctly simulated by HHH >>>>>>>>>>>> never reached its own simulated "return" statement final halt >>>>>>>>>>>> state.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>>>>> anyting else it is not a halt decider. If it does not return >>>>>>>>>>>>>>> it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the input to >>>>>>>>>>>>>> HHH(DD) as measured by the correct emulation of N steps of DD >>>>>>>>>>>>>> cannot possibly reach its own emulated "return" statement >>>>>>>>>>>>>> final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>>
If N = googolplex ^ googolplex then HHH never simulated that >>>>>>>>>>> many
steps.
Within the premise that HHH did simulate that many steps DD still >>>>>>>>>> did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the semantics of the >>>>>>>> x86 language can possibly reach its own "ret" instruction final >>>>>>>> halt
state is the only correct measure of the actual behavior of the >>>>>>>> actual input.
Irrelevant to the general truth that a counter-factual premise is >>>>>>> uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting problem >>>>>> proof because one is only interested in rebuttal and not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some extent >>>>> but you have never provided that and there is no reason to expect you >>>>> ever will.
The proof is not refuted by talking about something else and
pretending
it is not the same. The proof is only refuted by identifying a step
that is not a premise and is not an axiom and does not follow from
earlier steps.
Even if someone could find an error is a proof that would not be very >>>>> interesting as long as the conclusion remains proven by different
proofs.
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory of computation. All
deciders must only compute the mapping from their finite string input. >>>> Anything that is not a finite string input is outside of the scope of
any decider.
But a *description* of DD is a finite string.
And a description of a Turing machine is a Turing machine.
There is nothing else in a Turing machine.
In other words when you are hungry you can eat this word: "food".
On 8/15/2025 4:03 AM, Mikko wrote:
On 2025-08-14 17:22:24 +0000, olcott said:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>>>> anyting else
it is not a halt decider. If it does not return it is not >>>>>>>>>>>>>> a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation >>>>>>>>>>>>> of N steps of DD cannot possibly reach its own emulated >>>>>>>>>>>>> "return" statement final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement >>>>>>>>>>> final halt state.
If N = googolplex ^ googolplex then HHH never simulated that >>>>>>>>>> many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise
is uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some
extent but you have never provided that and there is no reason
to expect you ever will.
The proof is not refuted by talking about something else and
pretending it is not the same. The proof is only refuted by
identifying a step that is not a premise and is not an axiom
and does not follow from earlier steps.
Even if someone could find an error is a proof that would not be
very interesting as long as the conclusion remains proven by
different proofs.
*To see my proof*
*You must carefully study ALL the words*
I did carefully study every word between "Proof:" and "Q.E.D".
Halt deciders are only accountable for their inputs.
Halt deciders are NEVER accountable for NON-INPUTS.
On 8/15/2025 4:04 AM, Mikko wrote:
On 2025-08-14 17:58:49 +0000, Mr Flibble said:
On Thu, 14 Aug 2025 12:22:24 -0500, olcott wrote:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:*To see my proof*
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:If N = googolplex ^ googolplex DD correctly simulated by HHH >>>>>>>>>>>> never reached its own simulated "return" statement final halt >>>>>>>>>>>> state.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>>>>> halt decider.
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>>>>> anyting else it is not a halt decider. If it does not return >>>>>>>>>>>>>>> it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the input to >>>>>>>>>>>>>> HHH(DD) as measured by the correct emulation of N steps of DD >>>>>>>>>>>>>> cannot possibly reach its own emulated "return" statement >>>>>>>>>>>>>> final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>>
If N = googolplex ^ googolplex then HHH never simulated that many >>>>>>>>>>> steps.
Within the premise that HHH did simulate that many steps DD still >>>>>>>>>> did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the semantics of the >>>>>>>> x86 language can possibly reach its own "ret" instruction final halt >>>>>>>> state is the only correct measure of the actual behavior of the >>>>>>>> actual input.
Irrelevant to the general truth that a counter-factual premise is >>>>>>> uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting problem >>>>>> proof because one is only interested in rebuttal and not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some extent >>>>> but you have never provided that and there is no reason to expect you >>>>> ever will.
The proof is not refuted by talking about something else and pretending >>>>> it is not the same. The proof is only refuted by identifying a step
that is not a premise and is not an axiom and does not follow from
earlier steps.
Even if someone could find an error is a proof that would not be very >>>>> interesting as long as the conclusion remains proven by different
proofs.
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory of computation. All
deciders must only compute the mapping from their finite string input. >>>> Anything that is not a finite string input is outside of the scope of
any decider.
But a *description* of DD is a finite string.
And a description of a Turing machine is a Turing machine.
There is nothing else in a Turing machine.
In other words when you are hungry you can eat this word: "food".
On 8/15/2025 4:03 AM, Mikko wrote:
On 2025-08-14 17:22:24 +0000, olcott said:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider.
If it returns 'no' it is not a halt decider. If it returns anyting else
it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the
input to HHH(DD) as measured by the correct emulation >>>>>>>>>>>>> of N steps of DD cannot possibly reach its own emulated >>>>>>>>>>>>> "return" statement final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>
If N = googolplex ^ googolplex DD correctly simulated
by HHH never reached its own simulated "return" statement >>>>>>>>>>> final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise
is uninteresting and so are consequences inferred from a counter-
factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some
extent but you have never provided that and there is no reason
to expect you ever will.
The proof is not refuted by talking about something else and
pretending it is not the same. The proof is only refuted by
identifying a step that is not a premise and is not an axiom
and does not follow from earlier steps.
Even if someone could find an error is a proof that would not be
very interesting as long as the conclusion remains proven by
different proofs.
*To see my proof*
*You must carefully study ALL the words*
I did carefully study every word between "Proof:" and "Q.E.D".
Halt deciders are only accountable for their inputs.
Halt deciders are NEVER accountable for NON-INPUTS.
On 8/16/2025 2:26 AM, Mikko wrote:
On 2025-08-15 12:27:22 +0000, olcott said:
On 8/15/2025 4:04 AM, Mikko wrote:
On 2025-08-14 17:58:49 +0000, Mr Flibble said:
On Thu, 14 Aug 2025 12:22:24 -0500, olcott wrote:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:*To see my proof*
On 8/13/2025 3:01 AM, Mikko wrote:That you claim to have refuted the halting problem proof is not
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:If N = googolplex ^ googolplex DD correctly simulated by HHH >>>>>>>>>>>>>> never reached its own simulated "return" statement final halt >>>>>>>>>>>>>> state.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly >>>>>>>>>>>>>>>>>> simulates itsIt does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>>>>>>> halt decider.
input until:
(a) Detects a non-terminating behavior pattern: abort >>>>>>>>>>>>>>>>>> simulation and return 0.
(b) Simulated input reaches its simulated "return" >>>>>>>>>>>>>>>>>> statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>>>>>>> anyting else it is not a halt decider. If it does not >>>>>>>>>>>>>>>>> return
it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the >>>>>>>>>>>>>>>> input to
HHH(DD) as measured by the correct emulation of N steps >>>>>>>>>>>>>>>> of DD
cannot possibly reach its own emulated "return" statement >>>>>>>>>>>>>>>> final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>>>>
If N = googolplex ^ googolplex then HHH never simulated >>>>>>>>>>>>> that many
steps.
Within the premise that HHH did simulate that many steps DD >>>>>>>>>>>> still
did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are
consequences
inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the semantics >>>>>>>>>> of the
x86 language can possibly reach its own "ret" instruction
final halt
state is the only correct measure of the actual behavior of the >>>>>>>>>> actual input.
Irrelevant to the general truth that a counter-factual premise is >>>>>>>>> uninteresting and so are consequences inferred from a counter- >>>>>>>>> factual premise.
It may be uninteresting that I correctly refuted the halting
problem
proof because one is only interested in rebuttal and not truth. >>>>>>>
interesting. An actual refutation might be interesting to some
extent
but you have never provided that and there is no reason to expect >>>>>>> you
ever will.
The proof is not refuted by talking about something else and
pretending
it is not the same. The proof is only refuted by identifying a step >>>>>>> that is not a premise and is not an axiom and does not follow from >>>>>>> earlier steps.
Even if someone could find an error is a proof that would not be >>>>>>> very
interesting as long as the conclusion remains proven by different >>>>>>> proofs.
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory of computation. All >>>>>> deciders must only compute the mapping from their finite string
input.
Anything that is not a finite string input is outside of the scope of >>>>>> any decider.
But a *description* of DD is a finite string.
And a description of a Turing machine is a Turing machine.
There is nothing else in a Turing machine.
In other words when you are hungry you can eat this word: "food".
Does not follow.
The description of a Turing machine <is not> itself
a Turing machine. The word "food" in not somthing that you eat.
On 8/16/2025 2:29 AM, Mikko wrote:
On 2025-08-15 12:26:03 +0000, olcott said:
On 8/15/2025 4:03 AM, Mikko wrote:
On 2025-08-14 17:22:24 +0000, olcott said:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not >>>>>>>>>>>>>>>> a halt decider.
If it returns 'no' it is not a halt decider. If it >>>>>>>>>>>>>>>> returns anyting else
it is not a halt decider. If it does not return it is >>>>>>>>>>>>>>>> not a halt decider.
HHH(DD)==0 means that the behavior specified by the >>>>>>>>>>>>>>> input to HHH(DD) as measured by the correct emulation >>>>>>>>>>>>>>> of N steps of DD cannot possibly reach its own emulated >>>>>>>>>>>>>>> "return" statement final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>>>
If N = googolplex ^ googolplex DD correctly simulated >>>>>>>>>>>>> by HHH never reached its own simulated "return" statement >>>>>>>>>>>>> final halt state.
If N = googolplex ^ googolplex then HHH never simulated that >>>>>>>>>>>> many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are
consequences
inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise >>>>>>>> is uninteresting and so are consequences inferred from a counter- >>>>>>>> factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some
extent but you have never provided that and there is no reason
to expect you ever will.
The proof is not refuted by talking about something else and
pretending it is not the same. The proof is only refuted by
identifying a step that is not a premise and is not an axiom
and does not follow from earlier steps.
Even if someone could find an error is a proof that would not be
very interesting as long as the conclusion remains proven by
different proofs.
*To see my proof*
*You must carefully study ALL the words*
I did carefully study every word between "Proof:" and "Q.E.D".
Halt deciders are only accountable for their inputs.
Halt deciders are NEVER accountable for NON-INPUTS.
Accountability is not relevant. What does not meet the requirements
of a halt decider is not a halt decider.
Sum(3,4) is not accountable for the sum of 5 + 6.
HHH(DD) is not accountable for the behavior of DD().
On 8/16/2025 2:26 AM, Mikko wrote:
On 2025-08-15 12:27:22 +0000, olcott said:
On 8/15/2025 4:04 AM, Mikko wrote:
On 2025-08-14 17:58:49 +0000, Mr Flibble said:
On Thu, 14 Aug 2025 12:22:24 -0500, olcott wrote:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:*To see my proof*
On 8/13/2025 3:01 AM, Mikko wrote:That you claim to have refuted the halting problem proof is not
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:If N = googolplex ^ googolplex DD correctly simulated by HHH >>>>>>>>>>>>>> never reached its own simulated "return" statement final halt >>>>>>>>>>>>>> state.
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
Simulating Termination Analyzer HHH correctly simulates its >>>>>>>>>>>>>>>>>> input until:It does not really matter. If it returns 'yes' it is not a >>>>>>>>>>>>>>>>> halt decider.
(a) Detects a non-terminating behavior pattern: abort >>>>>>>>>>>>>>>>>> simulation and return 0.
(b) Simulated input reaches its simulated "return" >>>>>>>>>>>>>>>>>> statement: return 1.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return? >>>>>>>>>>>>>>>>>
If it returns 'no' it is not a halt decider. If it returns >>>>>>>>>>>>>>>>> anyting else it is not a halt decider. If it does not return >>>>>>>>>>>>>>>>> it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the input to >>>>>>>>>>>>>>>> HHH(DD) as measured by the correct emulation of N steps of DD >>>>>>>>>>>>>>>> cannot possibly reach its own emulated "return" statement >>>>>>>>>>>>>>>> final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>>>>
If N = googolplex ^ googolplex then HHH never simulated that many >>>>>>>>>>>>> steps.
Within the premise that HHH did simulate that many steps DD still >>>>>>>>>>>> did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the semantics of the >>>>>>>>>> x86 language can possibly reach its own "ret" instruction final halt >>>>>>>>>> state is the only correct measure of the actual behavior of the >>>>>>>>>> actual input.
Irrelevant to the general truth that a counter-factual premise is >>>>>>>>> uninteresting and so are consequences inferred from a counter- >>>>>>>>> factual premise.
It may be uninteresting that I correctly refuted the halting problem >>>>>>>> proof because one is only interested in rebuttal and not truth. >>>>>>>
interesting. An actual refutation might be interesting to some extent >>>>>>> but you have never provided that and there is no reason to expect you >>>>>>> ever will.
The proof is not refuted by talking about something else and pretending >>>>>>> it is not the same. The proof is only refuted by identifying a step >>>>>>> that is not a premise and is not an axiom and does not follow from >>>>>>> earlier steps.
Even if someone could find an error is a proof that would not be very >>>>>>> interesting as long as the conclusion remains proven by different >>>>>>> proofs.
*You must carefully study ALL the words*
I am correcting an erroneous aspect of the theory of computation. All >>>>>> deciders must only compute the mapping from their finite string input. >>>>>> Anything that is not a finite string input is outside of the scope of >>>>>> any decider.
But a *description* of DD is a finite string.
And a description of a Turing machine is a Turing machine.
There is nothing else in a Turing machine.
In other words when you are hungry you can eat this word: "food".
Does not follow.
The description of a Turing machine <is not> itself
a Turing machine.
The word "food" in not somthing that you eat.
On 8/16/2025 2:29 AM, Mikko wrote:
On 2025-08-15 12:26:03 +0000, olcott said:
On 8/15/2025 4:03 AM, Mikko wrote:
On 2025-08-14 17:22:24 +0000, olcott said:
On 8/14/2025 3:35 AM, Mikko wrote:
On 2025-08-13 15:08:34 +0000, olcott said:
On 8/13/2025 3:01 AM, Mikko wrote:
On 2025-08-12 14:47:56 +0000, olcott said:
On 8/12/2025 3:49 AM, Mikko wrote:
On 2025-08-11 14:39:30 +0000, olcott said:
On 8/11/2025 1:47 AM, Mikko wrote:
On 2025-08-10 15:30:04 +0000, olcott said:
On 8/10/2025 4:07 AM, Mikko wrote:
On 2025-08-07 13:02:51 +0000, olcott said:
On 8/7/2025 2:43 AM, Mikko wrote:
On 2025-08-06 18:34:33 +0000, olcott said:
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.
typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
What value should HHH(DD) correctly return?
It does not really matter. If it returns 'yes' it is not a halt decider.
If it returns 'no' it is not a halt decider. If it returns anyting else
it is not a halt decider. If it does not return it is not a halt decider.
HHH(DD)==0 means that the behavior specified by the >>>>>>>>>>>>>>> input to HHH(DD) as measured by the correct emulation >>>>>>>>>>>>>>> of N steps of DD cannot possibly reach its own emulated >>>>>>>>>>>>>>> "return" statement final halt state.
It can if N is twice the number of steps emulated by HHH. >>>>>>>>>>>>>>
If N = googolplex ^ googolplex DD correctly simulated >>>>>>>>>>>>> by HHH never reached its own simulated "return" statement >>>>>>>>>>>>> final halt state.
If N = googolplex ^ googolplex then HHH never simulated that many steps.
Within the premise that HHH did simulate that many
steps DD still did not reach its own simulated "return"
statement final halt state.
A counter-factual premise is uninteresting and so are consequences >>>>>>>>>> inferred from a counter-factual premise.
Whether or not DD emulated by HHH according to the
semantics of the x86 language can possibly reach
its own "ret" instruction final halt state is the
only correct measure of the actual behavior of the
actual input.
Irrelevant to the general truth that a counter-factual premise >>>>>>>> is uninteresting and so are consequences inferred from a counter- >>>>>>>> factual premise.
It may be uninteresting that I correctly refuted the halting
problem proof because one is only interested in rebuttal and
not truth.
That you claim to have refuted the halting problem proof is not
interesting. An actual refutation might be interesting to some
extent but you have never provided that and there is no reason
to expect you ever will.
The proof is not refuted by talking about something else and
pretending it is not the same. The proof is only refuted by
identifying a step that is not a premise and is not an axiom
and does not follow from earlier steps.
Even if someone could find an error is a proof that would not be
very interesting as long as the conclusion remains proven by
different proofs.
*To see my proof*
*You must carefully study ALL the words*
I did carefully study every word between "Proof:" and "Q.E.D".
Halt deciders are only accountable for their inputs.
Halt deciders are NEVER accountable for NON-INPUTS.
Accountability is not relevant. What does not meet the requirements
of a halt decider is not a halt decider.
Sum(3,4) is not accountable for the sum of 5 + 6.
HHH(DD) is not accountable for the behavior of DD().
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 162:28:52 |
| Calls: | 10,385 |
| Calls today: | 2 |
| Files: | 14,057 |
| Messages: | 6,416,502 |