From Newsgroup: comp.ai.philosophy

On 10/3/2026 8:05 AM, Python wrote:

Now we have reached a much more precise point, and I think your latest
reply exposes the exact logical issue.

You write:

HHH does correctly determine that its input DD does
specify a non-halting sequence of configurations if

(a) The words Professor Sipser agreed to are correct

(b) HHH derives this result by the application of
   correct finite string transformation rules to its input.

But (a) and (b) are not sufficient to establish your conclusion.

The statement you attribute to Professor Sipser is:

That was his agreement with my words.
This was the result of several back and forths
over several days.

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 D
specifies a non-halting sequence of configurations.

I accept this statement.

But its antecedent explicitly contains:

H correctly determines ...

H correctly determines

// line 1012
https://github.com/plolcott/x86utm/blob/master/Halt7.c
u32 Needs_To_Be_Aborted_HH(Decoded_Line_Of_Code* execution_trace)

that its simulated D would never stop running unless aborted...
It does this on the basis of correctly matching the infinite
recursion non-halting behavior pattern.

That is a semantic correctness condition. It does not say that whenever
H observes recursive simulation, H has thereby correctly determined that
its input specifies a non-halting computation.

would never stop running unless aborted...

So quoting this statement cannot establish that your particular function:

Needs_To_Be_Aborted_HH(execution_trace)

satisfies that antecedent for DD.

That still has to be proved.

In fact, your latest definition makes the problem especially clear.

You propose that the correct question is:

Does the finite string input DD to HHH specify a finite
sequence of configurations that will terminate normally
without needing to be aborted?

Fine.

I didn't say that. HHH is a non-halting decider for its entire
limited domain. That is equivalent to a halt decider for this
same limited domain. When HHH does not determine not halting
it simply waits for the simulation to stop on its own and
returns 1.

Now we must identify which sequence of configurations is meant.

HHH starts with DD and produces something like:

simulate DD

; DD reaches HHH(DD)
; simulate DD

      -> DD reaches HHH(DD)
      -> simulate DD
           -> ...

You say HHH recognizes that this sequence "would never stop running
unless aborted".

I agree.

Therefore HHH may correctly make the statement:

This simulation sequence will not terminate unless I abort it.

Thus exactly meeting the Professor Sipser approved criteria.

But you then want to infer:

Therefore my input DD specifies a non-halting computation.

As the Professor Sipser approved criteria agrees.

That inference is precisely what still requires proof.

if it meets the first paragraph condition as you have
already agreed to then the second paragraph is entailed.

Your appeal to Post does not supply it.

Applying correct finite string transformation rules guarantees that each transformation is legitimate. It does not guarantee that every semantic conclusion drawn from a finite prefix of those transformations is correct.

H correctly simulates its input D
// is the post finite string transformation rules

For example, suppose I correctly simulate a program for one billion
steps. Every single transformation can be perfectly correct. If I then say:

"It has not halted yet, therefore it will never halt"

My system recognizes the "infinite recursion" behavior pattern
and the "infinite loop" behavior pattern for its entire limited
domain.

the correctness of all preceding transformations does not make that inference correct.

You therefore need two different things:

1. correct simulation;

2. a correct inference rule establishing nontermination.

Your condition (b) appears to conflate them.

Recognizing non terminating behavior patterns listed above.

And this distinction is especially important because you explicitly say
that HHH has a limited domain.

If your claim is merely:

HHH decides nontermination for some restricted class of
computations for which Needs_To_Be_Aborted_HH provides
a sound nontermination test,

And the conventional halting problem counter-example
input is in this limited domain for HHH.

then there is no conflict whatsoever with the halting theorem.

Many restricted classes of programs have decidable termination.

But if your claim is that this defeats the diagonal halting argument,
then the difficult part is proving that DD belongs to that restricted
domain in the semantic sense required by the theorem.

Recognizing non terminating behavior patterns listed above.

And here your distinction between "what HHH actually sees" and a direct execution of DD does not help.

You explicitly acknowledge that DD can behave differently "within pathological self-reference (PSR)" and "without PSR", and then say that
HHH is accountable only for the behavior it actually sees.

That is a very important admission.

Yes. HHH is limited to the Emil Post requirement of applying
finite string transformation rules to actual inputs.

If:

behavior(DD under HHH's simulation context)

and:

behavior(DD in the computation whose halting is being asked about)

are different behaviors, then HHH is simply answering a different question.

It is answering the only question that is within the scope
of computation.

A halt decider is not defined as:

"Tell me whether the simulation strategy used internally by H
would have to be aborted."

Emil Post finite string transformation rules require this.

It is defined relative to the computation represented by its program/
input pair.

This also explains why your statement:

int main()
{
   DD(); // is not what HHH actually sees.
}

does not resolve anything.

Is resolved that the HP proof is asking a question that
is simply out-of-scope for computation.

Of course it is not what HHH internally sees.

A simulator sees an encoded representation and simulated configurations. That is true of every universal simulator.

The required property is not literal identity between the simulator's internal state and the simulated machine's physical execution.

The required property is semantic fidelity:

simulation(P, x) corresponds to computation(P, x).

That does not occur within a pathological self-reference
relationship, the focus of my primary research reverse-engineered
from first principles since 1998. I started with the Liar Paradox.

I proved the HP input is the same as the Liar Paradox back in 2004

On 6/23/2004 9:34 PM, Peter Olcott wrote:

function LoopIfYouSayItHalts (bool YouSayItHalts):
if YouSayItHalts () then
while true do {}
else
return false;

Does this program Halt?

(Your (YES or NO) answer is to be considered
translated to Boolean as the function's input
parameter)

Please ONLY PROVIDE CORRECT ANSWERS!

If you explicitly deny that correspondence for DD by saying that DD
under PSR has different behavior from DD without PSR, then you cannot
use the behavior under PSR to decide the behavior without PSR.

Yes. Thus asking HHH(DD) to report on the behavior of
int main() { DD(); } is incorrect.

You have separated the two computations yourself.

There is another important point.

You write:

When HHH sees a conditional branch then HHH does not abort.

Hence the limited domain.
AProVE: Non-Termination Witnesses for C Programs
has much more resources and can evaluate conditional
instructions. My system simply ignores them.

If there are no conditional instructions between the
invocation of a function and its call to another function
then HHH correctly determines that this function is invoked
unconditionally.

That makes the concrete implementation relevant.

DD itself contains a conditional branch:

if (Halt_Status)
   goto HERE;

That comes after it has already called HHH(DD).

Therefore, if your abort criterion nevertheless fires before that branch
can be reached

not by the simulated DD. Only by the DD() invoked in main() that
is an executing process and thus not a finite string input to HHH.
The correctly simulated DD cannot possibly get past its own line 03
whether or not HHH ever aborts.

because the simulated DD is blocked inside the recursive
simulated HHH(DD), then the criterion is detecting a property of the
nested simulation structure.

That may be a perfectly legitimate and useful property to detect.

It is the only correct detection within Emil Post finite string transformations.

But again:

"this nested simulation will recurse unless aborted"

is not automatically equivalent to:

"the computation denoted by the original DD is non-halting."

Bill is guilty of robbing the liquor store because his
identical twin brother Phil was seen robbing the liquor store.

The ONLY behavior that HHH is accountable for is the behavior
of its correct simulation of the finite string DD.

You need a theorem establishing that equivalence for every member of
your claimed domain.

The Sipser statement does not provide that theorem because it explicitly assumes that H has already "correctly determined" the relevant nontermination property.

See again non-halting behavior patterns detected at
// line 1012
https://github.com/plolcott/x86utm/blob/master/Halt7.c
u32 Needs_To_Be_Aborted_HH(Decoded_Line_Of_Code* execution_trace)

In logical form, the statement is essentially:

IF H correctly determines P,
THEN H may report P.

That is true.

But it cannot be used to establish:

H correctly determines P.

See again non-halting behavior patterns detected at
// line 1012
https://github.com/plolcott/x86utm/blob/master/Halt7.c
u32 Needs_To_Be_Aborted_HH(Decoded_Line_Of_Code* execution_trace)

Doing that would be circular.

And this is why the exact wording "would never stop running unless
aborted" does not change the issue.

See again non-halting behavior patterns detected at
// line 1012
https://github.com/plolcott/x86utm/blob/master/Halt7.c
u32 Needs_To_Be_Aborted_HH(Decoded_Line_Of_Code* execution_trace)

I agree that your recursive simulation would never stop running unless aborted.

You disagree with this below. You call it "The disputed step"

I agree that HHH can abort that simulation.

I agree that this can be derived through finite operations on finite representations.

None of those are the disputed step.

The disputed step is:

recursive simulation would never stop unless aborted

You just agreed with this above.

therefore

the original computation whose halting status is being
decided is non-halting.

You need to establish that implication independently.

There is a very simple way to settle this without any further discussion about Church, Turing, Post, Sipser, or terminology.

State the specification of HHH formally as a relation between its input
and its output.

HHH simulates DD until HHH correctly determines that the
behavior of DD exactly matches the infinite recursion
non-halting behavior pattern see the function at line
1012 of Halt7.c

For example:

HHH(P) = 1 iff ______________________________

HHH(P) = 0 iff ______________________________

Then state exactly what computation the right-hand side denotes.

Not "what HHH sees", not "what people expect it to look at", and not
"unless aborted".

Just identify the mathematical object whose termination the returned bit describes.

Then we can apply that specification to DD.

If HHH's result describes the termination behavior of DD itself, diagonalization applies.

diagonalization only seems to apply because of the false
assumption that the contradiction is reachable. Because
the contradiction exists in code that is unreachable it
never actually occurs.

?- LP = not(true(LP)).
LP = not(true(LP)).
?- unify_with_occurs_check(LP, not(true(LP))).
false.

Likewise the Liar Paradox only seems to be a
paradox because of the false assumption that
the contradiction is reachable.

If HHH's result instead describes whether HHH's internal simulation of
DD must be aborted, then HHH may very well compute that property, but it
is not deciding the same halting predicate.

The halting predicate has always required a result that
it outside of the scope of Emil Post computation.

This was never previously noticed because no one ever
bothered to concretely specify every single detail. The
key detail that the contradiction is never actually
reached was simply assumed away.

That distinction is now the entire issue.

--
Copyright 2026 Olcott

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