From Newsgroup: comp.ai.philosophy

On 10/7/2026 7:50 AM, Python wrote:

Peter, your Linz reference actually makes the distinction explicit.

Please use my notation conventions.
The Linz conventions enable too much ambiguity.
I spent five years writing and rewriting them for clarity.

Here is the same thing from Linz where H and Ĥ.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

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, // accept state
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // reject state

*Keeps repeating unless aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩

The key mistake of the Peter Linz Halting Problem proof is that
embedded_H is required to report on the behavior of Ĥ applied
to ⟨Ĥ⟩ (the computation that embedded_H is embedded within)
if Ĥ applied to ⟨Ĥ⟩ halts, and
if Ĥ applied to ⟨Ĥ⟩ does not halt

instead of the behavior specified by its own input finite string ⟨Ĥ⟩.
--
Copyright 2026 Olcott

The essence of computation is applying finite
string transformations to finite string inputs
to derive outputs. // paraphrase of Emil Post

My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable for the entire body of general knowledge.
The complete structure of this system is now defined.

The entire body of knowledge expressed in language is
comprised of two types of relations between finite strings:
(a) *Axioms* Expressions of language that are stipulated to be true.

My system bridges the analytic/synthetic distinction by
expressly encoding all empirical "atomic facts" in a formal
language such as CycL of the Cyc project.

(b) *Inference Rules* Expressions of language that are semantically
entailed syntactically from (a) and/or (b).
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 10/7/2026 8:16 AM, Python wrote:

Le 07/10/2026 à 15:07, olcott a écrit :

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 Ĥ.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

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.∞, // accept state
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn // reject state

*Keeps repeating unless aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩

The key mistake of the Peter Linz Halting Problem proof  is that
embedded_H is required to report on the behavior of Ĥ applied
to ⟨Ĥ⟩ (the computation that embedded_H  is embedded within)
if Ĥ applied to ⟨Ĥ⟩ halts, and
if Ĥ applied to ⟨Ĥ⟩ does not halt

instead of the behavior specified by its own input finite string ⟨Ĥ⟩. >>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its
     input D until H correctly determines that its simulated D
     would never stop running unless aborted then

     H can abort its simulation of D and correctly report that
     [the correctly simulated] D specifies a non-halting
     sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
[the correctly simulated] // inserted for clarity
it can already be inferred from the context.


https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/
dp/113318779X

You distinguish:

   (1) the behavior of Hhat(<Hhat>)

from:

   (2) the behavior specified by <Hhat>.

But in Linz, (2) specifies (1). That is what the machine encoding means.

Your claim is that under PSR this relation somehow breaks, and <Hhat> instead specifies only embedded_H's recursively nested simulation.

The Sipser quotation does not establish that. It only says that a
correctly determined non-halting simulated sequence may be reported as non-halting.

So the missing step remains:

   Why does <Hhat> cease to specify Hhat(<Hhat>)
   specifically under PSR?

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩

*Keeps repeating unless aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
thus meeting the Professor Sipser approved criteria

Until you prove that, your proposed distinction is a premise, not a conclusion.

--
Copyright 2026 Olcott

The essence of computation is applying finite
string transformations to finite string inputs
to derive outputs. // paraphrase of Emil Post

My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable for the entire body of general knowledge.
The complete structure of this system is now defined.

The entire body of knowledge expressed in language is
comprised of two types of relations between finite strings:
(a) *Axioms* Expressions of language that are stipulated to be true.

My system bridges the analytic/synthetic distinction by
expressly encoding all empirical "atomic facts" in a formal
language such as CycL of the Cyc project.

(b) *Inference Rules* Expressions of language that are semantically
entailed syntactically from (a) and/or (b).
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 10/7/2026 8:28 AM, Python wrote:

You distinguish:

   A. the behavior of Ĥ applied to ⟨Ĥ⟩

from:

   B. the behavior specified by embedded_H's
      finite-string input ⟨Ĥ⟩.

But you have not established that A and B are different things.

In the Linz construction, ⟨Ĥ⟩ is the finite description of Ĥ. Therefore
when embedded_H receives:

   ⟨Ĥ⟩ ⟨Ĥ⟩

the computation specified by those inputs is:

   Ĥ applied to ⟨Ĥ⟩.

Your recursive simulation keeps repeating unless aborted. Agreed.

The essence of a halt decider is applying correct
finite string transformations to finite string inputs
to derive accept/reject states. // paraphrase of Emil Post

Within my work "correct" is defined by the operational
semantics of the Turing Machine Description language.

Therefore the Halting Problem proofs have specified
a requirement that has always been outside the scope
of Emil Post computations.

This unequivocally proves that the Halting Problem
proofs have always been incorrect.

But here is an explicit contradiction test.

Suppose embedded_H reports NON-HALTING.

Then Ĥ follows the branch defined for that answer and HALTS.

Suppose embedded_H reports HALTING.

Then Ĥ follows the opposite branch and DOES NOT HALT.

Thus:

   embedded_H says NON-HALTING -> Ĥ(<Ĥ>) HALTS
   embedded_H says HALTING     -> Ĥ(<Ĥ>) DOES NOT HALT

And if embedded_H never reports either result, it is not a total halt decider.

This contradiction does not require embedded_H's simulation to reach
some special "contradiction state". It follows from comparing its
reported halt status with the behavior of the computation it is supposed
to classify.

Your proposed escape is:

   the behavior specified by ⟨Ĥ⟩
       !=
   the behavior of Ĥ applied to ⟨Ĥ⟩.

But that inequality is exactly what still needs proof.

So the question remains:

   Why does ⟨Ĥ⟩ cease to specify the behavior of
   Ĥ applied to ⟨Ĥ⟩ specifically in this PSR case?

The recursive simulation itself cannot prove that, because treating its behavior as the only behavior specified by ⟨Ĥ⟩ is precisely the disputed
premise.

--
Copyright 2026 Olcott

The essence of computation is applying finite
string transformations to finite string inputs
to derive outputs. // paraphrase of Emil Post

My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable for the entire body of general knowledge.
The complete structure of this system is now defined.

The entire body of knowledge expressed in language is
comprised of two types of relations between finite strings:
(a) *Axioms* Expressions of language that are stipulated to be true.

My system bridges the analytic/synthetic distinction by
expressly encoding all empirical "atomic facts" in a formal
language such as CycL of the Cyc project.

(b) *Inference Rules* Expressions of language that are semantically
entailed syntactically from (a) and/or (b).
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 10/7/2026 9:04 AM, Python wrote:

Peter, you have repeated your conclusion, but you have not answered the contradiction test.

The contradiction has always been unreachable.
No one ever noticed this before because no one
ever made ALL of the details 100% concrete before.

Let's make this as mechanical as possible.

For embedded_H(<Ĥ>,<Ĥ>) there are exactly three possibilities:

   1. embedded_H returns HALTING.

      By the definition of Ĥ:
          Ĥ(<Ĥ>) does not halt.

      Therefore embedded_H's answer is wrong.

embedded_H(<Ĥ>,<Ĥ>) is only reporting on this:
*Keeps repeating unless aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩

embedded_H(<Ĥ>,<Ĥ>) is not allowed to report on this:
Ĥ applied to ⟨Ĥ⟩

because this is outside of the scope of Emil Post
finite string transformations applied to finite
string inputs.

   2. embedded_H returns NON-HALTING.

      By the definition of Ĥ:
          Ĥ(<Ĥ>) halts.

      Therefore embedded_H's answer is wrong.

No that definition is wrong. It has always been
based on a false assumption and this false assumption
has always been the key mistake of the HP proofs.

The correct definition is this:
Does the input to Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
specify a finite sequence of configurations such that
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches its simulated
final halt state of ⟨Ĥ.qn⟩ ?

   3. embedded_H never returns an answer.

      Therefore embedded_H is not a total halt decider.

Which numbered case do you dispute, and which exact inference within
that case is invalid?

Saying:

   "the requirement is outside the scope
    of Emil Post computations"

does not answer this.

That is your proposed explanation for why the contradiction test

Has always been unreachable when-so-ever Emil Post finite
string transformation rules are correctly applied to finite
string inputs.

should
not apply. What I am asking you to identify is the precise invalid
inference IN the test.

I suspect your answer is that these statements are invalid:

   embedded_H returns HALTING
       -> compare that answer with whether Ĥ(<Ĥ>) halts

and

   embedded_H returns NON-HALTING
       -> compare that answer with whether Ĥ(<Ĥ>) halts.

If so, please say so explicitly.

Then our entire disagreement reduces to one precise proposition:

   Does the finite input <Ĥ><Ĥ> specify the computation
   Ĥ(<Ĥ>) for the purpose of the halting predicate?

The conventional proof says yes.

You say PSR makes the answer no.

*From the bottom of page 319 has been adapted to this* https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

This is the correct Emil Post Halting Problem proof
question when applied to the Olcott notional conventions
of the Peter Linz HP proof:

Does the input to Ĥ.embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
specify a finite sequence of configurations such that
⟨Ĥ⟩ ⟨Ĥ⟩ simulated by Ĥ.embedded_H reaches its simulated
final halt state of ⟨Ĥ.qn⟩ ?

THAT proposition, rather than the fact that computations manipulate
finite strings, is what you still need to prove.

So: which exact line of the three-case contradiction test is invalid?

All three are incorrect as explained in detail above.
--
Copyright 2026 Olcott

The essence of computation is applying finite
string transformations to finite string inputs
to derive outputs. // paraphrase of Emil Post

My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable for the entire body of general knowledge.
The complete structure of this system is now defined.

The entire body of knowledge expressed in language is
comprised of two types of relations between finite strings:
(a) *Axioms* Expressions of language that are stipulated to be true.

My system bridges the analytic/synthetic distinction by
expressly encoding all empirical "atomic facts" in a formal
language such as CycL of the Cyc project.

(b) *Inference Rules* Expressions of language that are semantically
entailed syntactically from (a) and/or (b).
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.ai.philosophy

On 10/7/2026 9:55 AM, Python wrote:

You reject:

   Does Ĥ(<Ĥ>) halt?

and replace it with:

   Does Ĥ.embedded_H's simulation of <Ĥ><Ĥ>
   reach its simulated halt state?

Those are different predicates.

The Halting Problem

Incorrectly

concerns the first one. If your HHH answers only the
second, you have not refuted the Halting Theorem; you have defined a different problem.

I have corrected the HP proof to exclude what
cannot be computed by Emil Post finite string
transformation rules.

And "the contradiction is unreachable" does not help: the contradiction
is not a machine state that must be reached. It is the logical incompatibility:

It is a machine state that has never been reachable within
the Emil Post finite string transformation rules.

   H says HALTING     -> Ĥ(<Ĥ>) does not halt
   H says NON-HALTING -> Ĥ(<Ĥ>) halts.

You avoid this only by declaring that H is not required to classify Ĥ(<Ĥ>).

Fine. Then the remaining thing you must prove is precisely:

   Why is "Does M(x) halt?" outside the scope
   of Emil Post computation?

Applying the Emil Post finite string transformation
rules to the Olcott Notation Conventions of the Peter
Linz HP proof derives the ONLY Emil Post relevant
behavior:

*Keeps repeating unless aborted*
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩

⟨Ĥ⟩ ⟨Ĥ⟩ correctly simulated by Ĥ.embedded_H cannot possibly
reach its own simulated final halt state of ⟨qn.Ĥ⟩.

If that is the ONLY Emil Post relevant behavior, then
any other behavior is necessarily irrelevant.

That does not follow merely from saying that computations transform
finite strings: <M> and x are finite strings.

--
Copyright 2026 Olcott

The essence of computation is applying finite
string transformations to finite string inputs
to derive outputs. // paraphrase of Emil Post

My 28 year goal has been to make
"true on the basis of meaning expressed in language"
reliably computable for the entire body of general knowledge.
The complete structure of this system is now defined.

The entire body of knowledge expressed in language is
comprised of two types of relations between finite strings:
(a) *Axioms* Expressions of language that are stipulated to be true.

My system bridges the analytic/synthetic distinction by
expressly encoding all empirical "atomic facts" in a formal
language such as CycL of the Cyc project.

(b) *Inference Rules* Expressions of language that are semantically
entailed syntactically from (a) and/or (b).
--- Synchronet 3.22a-Linux NewsLink 1.2