XPost: comp.theory, sci.logic

On 7/19/25 10:42 AM, olcott wrote:

On 7/18/2025 3:49 AM, joes wrote:

That is wrong. It is, as you say, very obvious that HHH cannot simulate
DDD past the call to HHH. You just draw the wrong conclusion from it.
(Aside: what "seems" to you will convince no one. You can just call
everybody dishonest. Also, they are not "your reviewers".)

For the purposes of this discussion this is the
100% complete definition of HHH. It is the exact
same one that I give to all the chat bots.

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

So, the only HHH that meets your definition is the HHH that never
detects the pattern and aborts, and thus never returns.

The problem is that once you define the pattern of DDD calling HHH(DDD)
and that HHH simulating the input to a second layer call of HHH(DDD) as non-halting, it no longer is, as then DDD() is a halting program.

Your problem is you refuse to actually understand what your words
actualy mean, things like "Program", "Non-Halting", and "Correct" seem
to be foreign to you.

I have always proved that HHH does simulate itself simulating DDD https://liarparadox.org/HHH(DDD)_Full_Trace.pdf

Right, but not that the pattern is non-halting, or that HHH CORRECTLY
(which requires completely) its input.

I have also always proved that DDD correctly simulated by
HHH cannot possibly reach its own "return" statement final
halt state.

No, you have only proved that for the HHH the never aborts and thus
never answers.

Since that is a different PROGRAM DDD then the program that the aborting
HHH sees, it is irrelevent.

*The following analysis cannot be correctly refuted* https://chatgpt.com/share/687aa4c2-b814-8011-9e7d-b85c03b291eb

Sure it can, as you said:

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.


But the pattern it detects is NOT proof of "non-terminating behavior" as
it also exists in the terminating behavior of the correctly simulated
DDD as done by HHH1.

Since you start with a false premise, the argument is just unsound, as
you have shown yourself to be.'

It also fails by the implied self-contradictory definition of "input"
you use, as you first imply that "the input" doesn't include the code of
HHH, so the "DDD" is a single constant input for the discussion, but you
also imply that it is part of "the input" so that HHH can simulate it.

That by itself makes the arguement invalid.

That this has been pointed out to you many times and you still make the
error means that you have shown that you either don't care about what is
the truth or are unable to learn the meaning of these basics terms due
to mental defect.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)

XPost: comp.theory, sci.logic

Op 21.jul.2025 om 16:19 schreef olcott:

On 7/21/2025 3:31 AM, Fred. Zwarts wrote:

Op 20.jul.2025 om 17:13 schreef olcott:

On 7/20/2025 2:47 AM, Fred. Zwarts wrote:

Op 19.jul.2025 om 17:50 schreef olcott:

On 7/19/2025 2:50 AM, Fred. Zwarts wrote:

No, the error in your definition has been pointed out to you many
times.
When the aborting HHH is simulated correctly, without disturbance, >>>>>> it reaches the final halt state.

I could equally "point out" that all cats are dogs.
Counter-factual statements carry no weight.

Irrelevant.
You cannot prove that cats are dogs, but the simulation by world class
simulators prove that exactly the same input specifies a halting program.

This trivial C function is the essence of my proof
(Entire input to the four chat bots)

<input>
typedef void (*ptr)();
int HHH(ptr P);

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.
</input>

No rebuttal, but repeated counter-factual claims.

All of the chat bots figure out on their own that the input
to HHH(DDD) is correctly rejected as non-halting.

No, we see that the detection of non-termination is the input for
the chat-box, not its conclusion.

https://chatgpt.com/c/687aa48e-6144-8011-a2be-c2840f15f285
*Below is quoted from the above link*

This creates a recursive simulation chain:
HHH(DDD)
   -> simulates DDD()
        -> calls HHH(DDD)
             -> simulates DDD()
                  -> calls HHH(DDD)
                       -> ...

Wich is counter-factual, because we know that HHH aborts before this
happens.

*Best selling author of theory of computation textbooks*
<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 D
     specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>

Irrelevant empty claim. No H can correctly simulate itself up to the
end. Since D calls H and we know that H halts, we know that a correct
simulation would show that H returns to D, after which D halts.
So, D halts.
The prerequisites 'correctly simulates' and 'correctly determines'
cannot be true, therefore the conclusion is irrelevant. It makes that
Sipser agreed to a vacuous statement.

As usual repeated claims without any new evidence, even though many
errors in them have been pointed out earlier.

The correct measure of the behavior of the input to HHH(DDD)
is DDD simulated by HHH according to the semantics of the C
programming language.

The behavior of the directly executed DDD() is not a correct
measure of the behavior of the input to HHH(DDD) because the
directly executed DDD() is not in the domain of HHH.

The HHH with bugs is not a correct measure for the behaviour specified
in its input.

HHH needs to report on the behaviour specified in its input. In this
case the input specifies a DDD that calls a HHH, which aborts and
returns, so the input specifies a halting program.
The semantics of the C programming language allows only one behaviour,
which is indeed seen in direct execution.
If HHH cannot reproduce the behaviour specified in the input, it just fails.

Both ChatGPT and Claude.ai demonstrate the equivalent of
complete understanding of this on the basis of their correct
paraphrase of my reasoning.

Although LLM systems are famous for hallucinations we
can see that this is not the case with their evaluation
of my work because their reasoning is sound.

It is a fact that Turing machine deciders cannot take
directly executed Turing machines as inputs.

It is a fact that the Halting Problem proofs require
a Turing machine decider to report on the behavior
of the direct execution of another Turing machine.

*That right there proves an error in the proof*

It only proves that chat-boxes generate nonsense when fed with nonsense.

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)