Five different LLM systems formed a consensus on
the basis of the verified fact that DD correctly
simulated by HHH cannot possibly reach its own
"return" statement final halt state in any finite
number of steps.
On 8/25/2025 12:25 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
Five different LLM systems formed a consensus on
the basis of the verified fact that DD correctly
simulated by HHH cannot possibly reach its own
"return" statement final halt state in any finite
number of steps.
Yeah, but you rigged it so that there is a fuse which has to be burned
in order to for DD to morph into a different DD' which is then correctly
simulated.
Not at all. You are suffering from confirmation
bias. You are so sure that I must be wrong that
you fail to pay enough attention to exactly what
I am saying.
With or without the fuse DD correctly simulated by
HHH cannot possibly reach its own "return" statement
final halt state in any finite number of steps.
Before that happens, there is an original DD which does halt.
*Not when we disable the use of the static data*
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 12:25 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
Five different LLM systems formed a consensus on
the basis of the verified fact that DD correctly
simulated by HHH cannot possibly reach its own
"return" statement final halt state in any finite
number of steps.
Yeah, but you rigged it so that there is a fuse which has to be burned >>>> in order to for DD to morph into a different DD' which is then
correctly
simulated.
Not at all. You are suffering from confirmation
bias. You are so sure that I must be wrong that
you fail to pay enough attention to exactly what
I am saying.
You've received an incredible amount of attention to every detail
of what you are saying, from numerous people over years.
For all of the last three years everyone has been gaslighting
me on the behavior of DD correctly simulated by HHH.
With or without the fuse DD correctly simulated by
HHH cannot possibly reach its own "return" statement
final halt state in any finite number of steps.
With the fuse, DD does do that. Including a simulated DD.
No you are not bothering to see what this trace is
you are assuming what it is and you are giving me
the wrong answer on this basis.
We are NOT talking about any simulated DD.
We are talking about DD simulated by HHH that
calls HHH(DD) IN RECURSIVE SIMULATION.
DD simulated by any HHH that can possibly exist
CAN POSSIBLY REACH ITS OWN SIMULATED "return"
STATEMENT FINAL HALT STATE.
We are NOT talking about any simulated DD.
We are talking about DD simulated by HHH
that
calls HHH(DD) IN RECURSIVE SIMULATION.
DD simulated by any HHH that can possibly exist
CAN POSSIBLY REACH ITS OWN SIMULATED "return"
STATEMENT FINAL HALT STATE.
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 12:25 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
Five different LLM systems formed a consensus on
the basis of the verified fact that DD correctly
simulated by HHH cannot possibly reach its own
"return" statement final halt state in any finite
number of steps.
Yeah, but you rigged it so that there is a fuse which has to be burned >>>> in order to for DD to morph into a different DD' which is then correctly >>>> simulated.
Not at all. You are suffering from confirmation
bias. You are so sure that I must be wrong that
you fail to pay enough attention to exactly what
I am saying.
You've received an incredible amount of attention to every detail
of what you are saying, from numerous people over years.
For all of the last three years everyone has been gaslighting
me on the behavior of DD correctly simulated by HHH.
With or without the fuse DD correctly simulated by
HHH cannot possibly reach its own "return" statement
final halt state in any finite number of steps.
With the fuse, DD does do that. Including a simulated DD.
No you are not bothering to see what this trace is
you are assuming what it is and you are giving me
the wrong answer on this basis.
We are NOT talking about any simulated DD.
We are talking about DD simulated by HHH that
calls HHH(DD) IN RECURSIVE SIMULATION.
DD simulated by any HHH that can possibly exist
CAN POSSIBLY REACH ITS OWN SIMULATED "return"
STATEMENT FINAL HALT STATE.
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the
counterexample test case against such an H, that test case will have
runway recursion (via nested simulation levels). In none of the DD
invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever made.
The counter-example input actually does have a correct non-contradicted
halt status.
Next is to transform HHH so that it can recognize the repeating state as
a pure function of its input. If I can do this that will complete my
work. Then I will have refuted the HP proofs.
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the
counterexample test case against such an H, that test case will have
runway recursion (via nested simulation levels). In none of the DD
invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever made.
The counter-example input actually does have a correct non-contradicted
halt status.
But we know that absolutely Every Turing Machine has a halt status:
either it halts or does not.
The decider has not halted and so has not calculated that status.
You are assigning an importance to this degenerate case which it doesn't have.
A decider that doesn't halt on non-terminating inputs is of worse
quality sophisticated one which is defeated by the actual contradictory behavior in the test case.
Next is to transform HHH so that it can recognize the repeating state as
a pure function of its input. If I can do this that will complete my
work. Then I will have refuted the HP proofs.
The problem is that you cannot be transforming HHH without
simultaneously be transforming the DD which is based on HHH.
If you split things so that DD retains its original HHH decider, while
you transform a copy of it to another one, then you have two deciders.
The two-decider arrangement doesn't refute anything.
You've already tried that with the static data. Any other means of
doing it is just as invalid.
You can easily have two different deciders HHH1 and HHH2 with no static
data trickery. Have DDD call HHH2(DD), and use HHH1(DD) to decide the halting of DD. That totally works; HHH1(DD) can produce the correct
value. It doesn't disprove anything.
The easiest way is to rename HHH to HHH1. Then make an exact copy HHH2
and fix DD to call HHH2(DD). Next, edit HHH1 to eliminate all the static
data stuff, and have it unconditionally behave as the abort-checking simulator. Similarly, edit HHH2 to get rid of the static data stuff, and
have it unconditionally be a pure simulator.
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 12:25 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
Five different LLM systems formed a consensus on
the basis of the verified fact that DD correctly
simulated by HHH cannot possibly reach its own
"return" statement final halt state in any finite
number of steps.
Yeah, but you rigged it so that there is a fuse which has to be
burned
in order to for DD to morph into a different DD' which is then
correctly
simulated.
Not at all. You are suffering from confirmation
bias. You are so sure that I must be wrong that
you fail to pay enough attention to exactly what
I am saying.
You've received an incredible amount of attention to every detail
of what you are saying, from numerous people over years.
For all of the last three years everyone has been gaslighting
me on the behavior of DD correctly simulated by HHH.
In all honesty, "gaslighting" describes the tricks you
are pulling in your code and the associated claims,
like HHH simulates itself and so .
void DDD()
{
 HHH(DDD);
 return;
}
_DDD()
[00002192] 55Â Â Â Â Â Â Â Â push ebp
[00002193] 8bec      mov ebp,esp
[00002195] 6892210000 push 00002192Â // push DDD
[0000219a] e833f4ffff call 000015d2Â // call HHH
[0000219f] 83c404Â Â Â Â add esp,+04
[000021a2] 5d        pop ebp
[000021a3] c3Â Â Â Â Â Â Â Â ret
Size in bytes:(0018) [000021a3]
(a) HHH executes.
(b) HHH creates a separate process context having
its own stack and set of 16 virtual registers
to simulate DDD using cooperative multi-tasking.
(c) HHH emulates the first four instructions of DDD
in this separate process context.
(d) HHH emulates an instance of itself in this same
process context.
(e) This HHH instance creates another process context
for its own emulated DDD instance.
(f) This HHH instance emulates the first three
instructions of DDD in this separate process
context and sees the call 000015d2 instruction.
It is a verified fact HHH did emulate DDD according
to the semantics of the x86 language. That *is* the
ultimate measure of correct emulation. Disagreeing
with the x86 language is necessarily incorrect.
With or without the fuse DD correctly simulated by
HHH cannot possibly reach its own "return" statement
final halt state in any finite number of steps.
With the fuse, DD does do that. Including a simulated DD.
No you are not bothering to see what this trace is
you are assuming what it is and you are giving me
the wrong answer on this basis.
We are NOT talking about any simulated DD.
We are talking about DD simulated by HHH that
calls HHH(DD) IN RECURSIVE SIMULATION.
Yes, I get it. Out of main we call HHH(DD). That begins a step-wise
simulation of DD, (but with the static fuse in place, it does an
incorrect thing by changing the behavior of DD via that change in static
data; it changes DD from a halting one to non-halting).
I looked into your idea. It should be
easy to implement.
Anyway, the step-wise simulated DD calls HHH(DD) so that is simulated
also. Due
to the change in static data, HHH(DD) is now runaway recursive (doesn't
perform the abort criteria checks) whereas the top-level HHH does.
What am I missing?
DD simulated by any HHH that can possibly exist
CAN POSSIBLY REACH ITS OWN SIMULATED "return"
STATEMENT FINAL HALT STATE.
I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the
counterexample test case against such an H, that test case will have
runway recursion (via nested simulation levels). In none of the DD
invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever made.
The counter-example input actually does have a correct non-contradicted
halt status.
Next is to transform HHH so that it can recognize the repeating state as
a pure function of its input. If I can do this that will complete my
work. Then I will have refuted the HP proofs.
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 12:25 PM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
Five different LLM systems formed a consensus on
the basis of the verified fact that DD correctly
simulated by HHH cannot possibly reach its own
"return" statement final halt state in any finite
number of steps.
Yeah, but you rigged it so that there is a fuse which has to be burned >>>>>> in order to for DD to morph into a different DD' which is then correctly >>>>>> simulated.
Not at all. You are suffering from confirmation
bias. You are so sure that I must be wrong that
you fail to pay enough attention to exactly what
I am saying.
You've received an incredible amount of attention to every detail
of what you are saying, from numerous people over years.
For all of the last three years everyone has been gaslighting
me on the behavior of DD correctly simulated by HHH.
In all honesty, "gaslighting" describes the tricks you
are pulling in your code and the associated claims,
like HHH simulates itself and so .
void DDD()
{
HHH(DDD);
return;
}
_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192 // push DDD
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]
(a) HHH executes.
(b) HHH creates a separate process context having
its own stack and set of 16 virtual registers
to simulate DDD using cooperative multi-tasking.
(c) HHH emulates the first four instructions of DDD
in this separate process context.
(d) HHH emulates an instance of itself in this same
process context.
(e) This HHH instance creates another process context
for its own emulated DDD instance.
(f) This HHH instance emulates the first three
instructions of DDD in this separate process
context and sees the call 000015d2 instruction.
It is a verified fact HHH did emulate DDD according
to the semantics of the x86 language. That *is* the
ultimate measure of correct emulation. Disagreeing
with the x86 language is necessarily incorrect.
With or without the fuse DD correctly simulated by
HHH cannot possibly reach its own "return" statement
final halt state in any finite number of steps.
With the fuse, DD does do that. Including a simulated DD.
No you are not bothering to see what this trace is
you are assuming what it is and you are giving me
the wrong answer on this basis.
We are NOT talking about any simulated DD.
We are talking about DD simulated by HHH that
calls HHH(DD) IN RECURSIVE SIMULATION.
Yes, I get it. Out of main we call HHH(DD). That begins a step-wise
simulation of DD, (but with the static fuse in place, it does an
incorrect thing by changing the behavior of DD via that change in static
data; it changes DD from a halting one to non-halting).
I looked into your idea. It should be
easy to implement.
Anyway, the step-wise simulated DD calls HHH(DD) so that is simulated also. Due
to the change in static data, HHH(DD) is now runaway recursive (doesn't
perform the abort criteria checks) whereas the top-level HHH does.
What am I missing?
DD simulated by any HHH that can possibly exist
CAN POSSIBLY REACH ITS OWN SIMULATED "return"
STATEMENT FINAL HALT STATE.
I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the
counterexample test case against such an H, that test case will have
runway recursion (via nested simulation levels). In none of the DD
invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever made.
The counter-example input actually does have a correct non-contradicted halt status.
Next is to transform HHH so that it can recognize the repeating state as
a pure function of its input. If I can do this that will complete my work. Then I will have refuted
the HP proofs.
On 8/26/2025 1:39 AM, Kaz Kylheku wrote:
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the
counterexample test case against such an H, that test case will have
runway recursion (via nested simulation levels). In none of the DD
invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever made. >>> The counter-example input actually does have a correct non-contradicted
halt status.
But we know that absolutely Every Turing Machine has a halt status:
either it halts or does not.
As soon as HHH(DD) can return 0 as a pure function
of its input the HP proofs have been defeated.
If you split things so that DD retains its original HHH decider, while
you transform a copy of it to another one, then you have two deciders.
The two-decider arrangement doesn't refute anything.
A decider that must have a dry run to be initialized
before its performs its analysis is not two deciders.
The easiest way is to rename HHH to HHH1. Then make an exact copy HHH2
and fix DD to call HHH2(DD). Next, edit HHH1 to eliminate all the static
data stuff, and have it unconditionally behave as the abort-checking
simulator. Similarly, edit HHH2 to get rid of the static data stuff, and
have it unconditionally be a pure simulator.
Since you said that won't prove anything that it no good.
On 8/26/2025 1:39 AM, Kaz Kylheku wrote:
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the
counterexample test case against such an H, that test case will have
runway recursion (via nested simulation levels). In none of the DD
invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever made. >>> The counter-example input actually does have a correct non-contradicted
halt status.
But we know that absolutely Every Turing Machine has a halt status:
either it halts or does not.
As soon as HHH(DD) can return 0 as a pure function
of its input the HP proofs have been defeated.
The decider has not halted and so has not calculated that status.
You are assigning an importance to this degenerate case which it doesn't
have.
A decider that doesn't halt on non-terminating inputs is of worse
quality sophisticated one which is defeated by the actual contradictory
behavior in the test case.
Next is to transform HHH so that it can recognize the repeating state as >>> a pure function of its input. If I can do this that will complete my
work. Then I will have refuted the HP proofs.
The problem is that you cannot be transforming HHH without
simultaneously be transforming the DD which is based on HHH.
*Ultimately is is just the adapted Linz proof*
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
Turing Machine Linz Ĥ applied to its own machine description ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞
  if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches
  its simulated final halt state of ⟨Ĥ.qn⟩, and
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
  if ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H cannot possibly
  reach its simulated final halt state of ⟨Ĥ.qn⟩.
Repeats until aborted
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
If you split things so that DD retains its original HHH decider, while
you transform a copy of it to another one, then you have two deciders.
The two-decider arrangement doesn't refute anything.
A decider that must have a dry run to be initialized
before its performs its analysis is not two deciders.
You've already tried that with the static data. Any other means of
doing it is just as invalid.
FIVE LLM systems were able to do a pseudo execution
trace of DD correctly simulated by HHH and derive
my same conclusion.
You can easily have two different deciders HHH1 and HHH2 with no static
data trickery. Have DDD call HHH2(DD), and use HHH1(DD) to decide the
halting of DD. That totally works; HHH1(DD) can produce the correct
value. It doesn't disprove anything.
So I won't do it that way.
Five LLM systems could do this on the basis of a text file
thus as a pure function of their input.
The easiest way is to rename HHH to HHH1. Then make an exact copy HHH2
and fix DD to call HHH2(DD). Next, edit HHH1 to eliminate all the static
data stuff, and have it unconditionally behave as the abort-checking
simulator. Similarly, edit HHH2 to get rid of the static data stuff, and
have it unconditionally be a pure simulator.
Since you said that won't prove anything that it no good.
On 8/26/2025 11:37 AM, Kaz Kylheku wrote:In other words: you have proven that the HHH that aborts as well as the
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 1:39 AM, Kaz Kylheku wrote:
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of
deciders which blindly simulate their input, and then if we build the >>>>>> counterexample test case against such an H, that test case will have >>>>>> runway recursion (via nested simulation levels). In none of the DD >>>>>> invocation does the H(DDD) expression terminate; so the "opposite
behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has ever
made.
The counter-example input actually does have a correct non-
contradicted
halt status.
But we know that absolutely Every Turing Machine has a halt status:
either it halts or does not.
As soon as HHH(DD) can return 0 as a pure function
of its input the HP proofs have been defeated.
The problem is that here is what it means for HHH to be a pure function:
all uses of HHH are identical, denoting the same computation. If HHH(DD)
returns 0, and is a pure function call (as required) it means that every
instance of that expression HHH(DD) everywhere returns 0. One such
instance is inside the test case DD.
Those instances of HHH that are themselves stuck
in recursive emulation cannot possibly return.
If you split things so that DD retains its original HHH decider, while >>>> you transform a copy of it to another one, then you have two deciders. >>>>
The two-decider arrangement doesn't refute anything.
A decider that must have a dry run to be initialized
before its performs its analysis is not two deciders.
If we have a procedure that behaves in various inconsistent ways when it
is invoked the first N time, modifying its state, but after N calls
settles into a consistent behavior in which all subsequent calls denote
the same computation, we can allow ourselves to model those subsequent
calls as a pure function call.
This is an easy fix.
If our experiment relies on any of the first N calls though, then we
have impurity in the experiment which amounts to multiple functions
where we crucially need there to be one function.
I have proven that DD correctly simulated by HHH
cannot possibly reach its own simulated "return"
statement final halt state by the fact that disabling
the abort causes DD() to never stop.
On 8/27/2025 2:57 AM, Fred. Zwarts wrote:
Op 26.aug.2025 om 18:53 schreef olcott:
On 8/26/2025 11:37 AM, Kaz Kylheku wrote:In other words: you have proven that the HHH that aborts as well as
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 1:39 AM, Kaz Kylheku wrote:
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of >>>>>>>> deciders which blindly simulate their input, and then if we
build the
counterexample test case against such an H, that test case will >>>>>>>> have
runway recursion (via nested simulation levels). In none of the DD >>>>>>>> invocation does the H(DDD) expression terminate; so the "opposite >>>>>>>> behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has
ever made.
The counter-example input actually does have a correct non-
contradicted
halt status.
But we know that absolutely Every Turing Machine has a halt status: >>>>>> either it halts or does not.
As soon as HHH(DD) can return 0 as a pure function
of its input the HP proofs have been defeated.
The problem is that here is what it means for HHH to be a pure
function:
all uses of HHH are identical, denoting the same computation. If
HHH(DD)
returns 0, and is a pure function call (as required) it means that
every
instance of that expression HHH(DD) everywhere returns 0. One such
instance is inside the test case DD.
Those instances of HHH that are themselves stuck
in recursive emulation cannot possibly return.
If you split things so that DD retains its original HHH decider,
while
you transform a copy of it to another one, then you have two
deciders.
The two-decider arrangement doesn't refute anything.
A decider that must have a dry run to be initialized
before its performs its analysis is not two deciders.
If we have a procedure that behaves in various inconsistent ways
when it
is invoked the first N time, modifying its state, but after N calls
settles into a consistent behavior in which all subsequent calls denote >>>> the same computation, we can allow ourselves to model those subsequent >>>> calls as a pure function call.
This is an easy fix.
If our experiment relies on any of the first N calls though, then we
have impurity in the experiment which amounts to multiple functions
where we crucially need there to be one function.
I have proven that DD correctly simulated by HHH
cannot possibly reach its own simulated "return"
statement final halt state by the fact that disabling
the abort causes DD() to never stop.
the HHH that does not abort both fail to reach the final halt state.
I have proven that DD correctly simulated by HHH
specifies the non-halting behavior pattern of
recursive simulation.
Until you understand this you will lack the mandatory
prerequisite to understand the rest.
The only difference is that the input based on the HHH that aborts has
a final halt state and the input based on the HHH that does not abort
does not terminate.
In both cases, however, HHH fails. The HHH hat aborts fails because it
does not reach the final halt state specified in the input and returns
an incorrect result. The HHH that does not abort fails because it does
not report.
The premature abort of HHH, which makes that it cannot reach the final
halt state, does not change the specification of only a finite recursion.
On 8/27/2025 2:57 AM, Fred. Zwarts wrote:
Op 26.aug.2025 om 18:53 schreef olcott:
On 8/26/2025 11:37 AM, Kaz Kylheku wrote:In other words: you have proven that the HHH that aborts as well as
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 1:39 AM, Kaz Kylheku wrote:
On 2025-08-26, olcott <polcott333@gmail.com> wrote:
On 8/26/2025 12:34 AM, Kaz Kylheku wrote:
On 2025-08-25, olcott <polcott333@gmail.com> wrote:
On 8/25/2025 6:03 PM, Kaz Kylheku wrote:I agree that if we take any decider H from the special subset of >>>>>>>> deciders which blindly simulate their input, and then if we
build the
counterexample test case against such an H, that test case will >>>>>>>> have
runway recursion (via nested simulation levels). In none of the DD >>>>>>>> invocation does the H(DDD) expression terminate; so the "opposite >>>>>>>> behavior" doesn't even kick in.
Thus, halt-deciding by simulation is a non-starter.
Great, so what?
That by itself seems to be more progress than anyone else has
ever made.
The counter-example input actually does have a correct non-
contradicted
halt status.
But we know that absolutely Every Turing Machine has a halt status: >>>>>> either it halts or does not.
As soon as HHH(DD) can return 0 as a pure function
of its input the HP proofs have been defeated.
The problem is that here is what it means for HHH to be a pure
function:
all uses of HHH are identical, denoting the same computation. If
HHH(DD)
returns 0, and is a pure function call (as required) it means that
every
instance of that expression HHH(DD) everywhere returns 0. One such
instance is inside the test case DD.
Those instances of HHH that are themselves stuck
in recursive emulation cannot possibly return.
If you split things so that DD retains its original HHH decider,
while
you transform a copy of it to another one, then you have two
deciders.
The two-decider arrangement doesn't refute anything.
A decider that must have a dry run to be initialized
before its performs its analysis is not two deciders.
If we have a procedure that behaves in various inconsistent ways
when it
is invoked the first N time, modifying its state, but after N calls
settles into a consistent behavior in which all subsequent calls denote >>>> the same computation, we can allow ourselves to model those subsequent >>>> calls as a pure function call.
This is an easy fix.
If our experiment relies on any of the first N calls though, then we
have impurity in the experiment which amounts to multiple functions
where we crucially need there to be one function.
I have proven that DD correctly simulated by HHH
cannot possibly reach its own simulated "return"
statement final halt state by the fact that disabling
the abort causes DD() to never stop.
the HHH that does not abort both fail to reach the final halt state.
I have proven that DD correctly simulated by HHH
specifies the non-halting behavior pattern of
recursive simulation.
Until you understand this you will lack the mandatory
prerequisite to understand the rest.
The only difference is that the input based on the HHH that aborts has
a final halt state and the input based on the HHH that does not abort
does not terminate.
In both cases, however, HHH fails. The HHH hat aborts fails because it
does not reach the final halt state specified in the input and returns
an incorrect result. The HHH that does not abort fails because it does
not report.
The premature abort of HHH, which makes that it cannot reach the final
halt state, does not change the specification of only a finite recursion.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 546 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 07:22:23 |
| Calls: | 10,386 |
| Calls today: | 1 |
| Files: | 14,058 |
| Messages: | 6,416,643 |