Now the disagreement is completely explicit.
You say:
-a-a Nothing because the whole recursive chain has been aborted.
That is precisely the problem.
If HHH aborts the entire simulated computation, then it has not
established that DD itself specifies a non-halting computation. It has established that the particular simulation procedure being performed by
HHH would recurse indefinitely unless HHH intervenes.
Those are different propositions.
Consider your quoted statement:
-a-a If simulating halt decider H correctly simulates its
-a-a input D until H correctly determines that its simulated D
-a-a would never stop running unless aborted then
-a-a H can abort its simulation of D and correctly report that D
-a-a specifies a non-halting sequence of configurations.
I have no objection to that statement as written.
The crucial phrase is:
-a-a correctly determines
HHH simulates DD
DD calls HHH(DD)
HHH simulates DD
DD calls HHH(DD)
HHH simulates DD
...
Therefore the simulated DD never gets past line 03.
I agree.
That phrase assumes the very thing that must be proved.
For an ordinary infinite loop such as:
-a-a D()
-a-a {
-a-a-a-a-a-a while (1) {}
-a-a }
H may have some sound method proving that D specifies a non-halting computation.
But DD is different because the behavior of DD depends on the result returned by HHH(DD).
You cannot establish that DD is non-halting merely by observing that recursive simulation occurs when HHH attempts to simulate DD. You must establish that the actual computation specified by DD is non-halting.
And this brings us directly to your second claim:
-a-a When HHH is called from DD() this is not the input
-a-a finite string to HHH and HHH is only accountable
-a-a Emil Post computations.
This does not solve the problem.
The source text or machine description of DD is a finite string.
The description of HHH is also a finite string.
The configuration representing:
-a-a DD executing line 03 and invoking HHH(DD)
is finite.
The next configuration is finite.
Every individual configuration in the recursive computation is finite.
Every transition between configurations is determined by finite rules.
Thus:
-a-a DD -> HHH(DD) -> simulated DD -> simulated HHH(DD) -> ...
HHH simulates DD
DD calls HHH(DD)
HHH simulates DD
DD calls HHH(DD)
HHH simulates DD
...
is perfectly representable as a sequence of finite configurations
generated by finite transition rules.
The fact that the sequence may be infinite does not violate Post's formulation.
That distinction is essential.
"Finite string transformations" does NOT mean that every computation
must contain only finitely many transformations.
It means that computation proceeds by finitely specified operations on finite symbolic configurations.
A Turing machine that runs forever is still a Turing-machine computation.
Likewise, an infinite Post production sequence does not suddenly become something outside computation theory merely because it has infinitely
many successive configurations.
Otherwise the halting problem would become meaningless by definition:
every non-halting computation would simply be declared "outside the
scope" because it contains infinitely many steps.
There is an even more fundamental problem with saying:
-a-a All of it seems to be referring to DD() calling HHH
-a-a and this violates Emil Post.
DD calling HHH cannot simultaneously be:
HHH simulates DD
DD calls HHH(DD)
HHH simulates DD
DD calls HHH(DD)
HHH simulates DD
...
1. forbidden as something outside the computational model,
and
2. something HHH correctly simulates according to the operational
semantics of C.
Your own simulation trace contains exactly that call:
-a-a simulated DD()
-a-a-a-a-a-a invokes simulated HHH(DD)
You used that transition to establish your invariant:
-a-a DD correctly simulated by HHH cannot possibly
-a-a reach past its own line 03.
So the call cannot suddenly become inadmissible when we ask what follows from it.
If:
-a-a simulated DD -> simulated HHH(DD)
is a legitimate transition when establishing your invariant, then it
remains a legitimate transition when analyzing what HHH's answer means.
There is also a deeper issue with:
-a-a Nothing because the whole recursive chain has been aborted.
Suppose HHH reaches some finite configuration C and recognizes the
recursive pattern.
HHH then performs an operation such as:
-a-a abort simulation;
-a-a return 0;
Fine. That is itself just another finite computational transition.
Now ask what proposition the returned 0 asserts.
If it asserts:
-a-a "The simulation I just aborted would have continued recursively"
then I agree.
But that is not a solution to the halting problem.
A halt decider must answer the relevant question about its input computation:
-a-a "Does the computation specified by DD halt?"
If 0 means:
-a-a "DD does not halt"
then the answer must correspond to the semantics of DD.
And DD contains:
-a-a Halt_Status = HHH(DD);
Therefore the value returned by HHH is semantically relevant to DD's behavior.
You cannot say both:
-a-a HHH returns 0 as the answer about DD
and:
-a-a DD never receives that 0 because I aborted DD.
The latter describes what HHH did to
its private simulation.
It does not establish what DD does when HHH returns 0.
This is the distinction between:
-a-a aborting a simulation of P
and:
-a-a proving that P itself does not halt.
For example, I can write a simulator S that simulates any program for
1000 steps and then aborts.
When S aborts the simulation of P, obviously P does not receive anything from S.
But that tells us absolutely nothing about whether P itself would
eventually halt.
Your proposed HHH needs something stronger: a sound criterion proving
that the aborted infinite-looking simulation corresponds to a genuinely non-halting computation of DD.
And with DD, that is exactly where diagonalization matters.
If HHH returns "non-halting", DD is defined to take the non-looping branch.
If HHH returns "halting", DD is defined to take the looping branch.
Aborting HHH's internal simulation does not remove this semantic
dependency.
It merely prevents the simulated copy from continuing.
So I think we have finally isolated the exact issue.
I agree that HHH may abort its own simulation.
I agree that the recursive simulation, if allowed to continue, produces
an unbounded sequence of nested simulations.
I agree that HHH can detect some such patterns if you provide an
effective detection rule.
What has not been established is the following implication:
-a-a "HHH's simulation of DD would recurse forever"
therefore
-a-a "DD specifies a non-halting computation"
because DD's behavior depends on the answer produced by HHH.
And appealing to Emil Post does not eliminate that dependency. The
source of DD, the source of HHH, every configuration involved, and every individual transition are all finite symbolic objects governed by finite rules.
So there is now one very precise question:
When HHH aborts the recursive simulation and reports "DD does not halt", what finite-string computation establishes that this statement is about
the behavior specified by DD, rather than merely about the
nontermination of the simulation that HHH has just aborted?
That is the missing step.
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
On 10/2/2026 8:58 AM, Python wrote:
Le 02/10/2026 |a 15:56, olcott a |-crit :
On 10/2/2026 8:32 AM, Python wrote:
Le 02/10/2026 |a 15:24, olcott a |-crit :It has taken me many thousands of hours very carefully
On 10/2/2026 7:59 AM, Python wrote:
Le 02/10/2026 |a 14:28, olcott a |-crit :
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, >>>>>>>>> so what?
it is solvable for an enumerable set of machines that includes >>>>>>>> all possible output sequences, it is not solvable for all
possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
https://github.com/plolcott/x86utm/blob/master/README.md
This is outside of the Church-Turing scope when this scope
is understood to only allow finite string transformation
rules to be applied to finite string inputs to derive any
any all outputs.
The only correct finite string transformation rules that
HHH is allowed to apply to its finite string input DD are
specified by the operational semantics of the C programming
language.
There are no correct finite string transformation rules that
HHH can possibly apply to its input finite string that derive
the behavior of DD directly executed in main().
Peter, this distinction between "the operational semantics of C"
and "the behavior of DD directly executed from main()" does not
exist.
Counter-factual you just did not pay close enough
attention and merely leaped to a false conclusion.
Peter, saying "counter-factual" is not a counterargument.
compose the few words that I just said. Carefully
study them for a few hours until you fully understand
every subtle nuance of every single detail before you
reply.
Peter, the number of hours you spent composing a statement has no
bearing on whether it is true.
That is true, None-the-less I will no longer
tolerate people that glance at a couple of
my words before artificially contriving a
rebuttal that conclusively proves that they
did not bother to pay complete attention
to every detail of what I said.
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so
what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or "main()".
The halting problem asks "How can one determine whether a computation
halts?"
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so
what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or "main()".
The halting problem asks "How can one determine whether a computation
halts?"
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:The key mistake of the halting theorem is that
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so
what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines >>>
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or "main()".
The halting problem asks "How can one determine whether a computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:The key mistake of the halting theorem is that
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so
what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines >>>
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or "main()".
The halting problem asks "How can one determine whether a computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
On 09/10/2026 14:40, olcott wrote:
On 10/9/2026 3:18 AM, Mikko wrote:
On 07/10/2026 15:25, polcott wrote:
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, >>>>>>>> so what?
it is solvable for an enumerable set of machines that includes
all possible output sequences, it is not solvable for all
possible machines
The key mistake of the halting theorem is that
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or
"main()".
The halting problem asks "How can one determine whether a computation >>>>> halts?"
Here is the same thing from Linz where H and -n.embedded_H are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this*
Earlier on that page Linz says: "Simply stated, the problem is: given
the description of a Turing machine M and an input w, does M, when
started in the initial configuration qow, perform a computation that
eventually halts?"
At the bottom of the page, continuing to the next page, is a formal
definition of the solution of the halting problem, which Linz defines
as a Turing machine.
https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
There is no "embedded_H" in Linz's definition.
<Linz text>
-aFrom H' we construct another Turing machine -n.
That is later in the text, not in the definition 12.1, so irrelevant
to this discussion.
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:The key mistake of the halting theorem is that
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so
what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines >>>
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or "main()".
The halting problem asks "How can one determine whether a computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.reR, // accept state
-n.q0 rf?-nrf- reo* -n.embedded_H rf?-nrf- rf?-nrf- reo* -n.qn // reject state
*Keeps repeating unless aborted*
(a) -n copies its input rf?-nrf-
(b) -n invokes embedded_H rf?-nrf- rf?-nrf-
(c) embedded_H simulates rf?-nrf- rf?-nrf-
On 10/7/2026 5:40 AM, Mikko wrote:
On 02/10/2026 15:28, olcott wrote:
On 10/1/2026 10:05 PM, dart200 wrote:
On 10/1/26 5:28 PM, Chris M. Thomasson wrote:The key mistake of the halting theorem is that
On 10/1/2026 3:54 PM, dart200 wrote:
[...]
Are you saying that the halting problem is not solvable? If so, so
what?
it is solvable for an enumerable set of machines that includes all
possible output sequences, it is not solvable for all possible machines >>>
it requires a halt decider to report on the behavior
of the direct execution of DD() from main()
No, it isn't. The halting problem says nothing about "DD()" or "main()".
The halting problem asks "How can one determine whether a computation
halts?"
Here is the same thing from Linz where H and -n.embedded_H are
also based on UTM simulation of their inputs.
*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:48:33 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,582 |