Anyone with sufficient knowledge of C knows that DD specifies non-terminating behavior to HHH

[olcott]

Experts in the C programming language will know that DD
correctly simulated by HHH cannot possibly reach its own
"if" statement.

The finite string DD specifies non-terminating recursive
simulation to simulating termination analyzer HHH. This
makes HHH necessarily correct to reject its input as
non-halting.

typedef void (*ptr)();
int HHH(ptr P);

int DD()
{
int Halt_Status = HHH(DD);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
HHH(DD);
}

https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D


https://github.com/plolcott/x86utm/blob/master/Halt7.c
has fully operational HHH and DD

The halting problem has always been a mathematical mapping
from finite strings to behaviors. That people do not comprehend
this shows the shallowness of the depth of the learned-by-rote
(lack of) understanding.

[olcott]

Post by olcott

Of course not. However, the fact that no reference to that article
before or when HHH

That paper and its code are the only thing that I have been
talking about in this forum for several years.

Doesn't matter when you don't say that you are talking about that
paper.
Anyway, that is irrelevant to the fact that the subject line
contains
a false claim.

It is a truism and not one person on the face of the
Earth can possibly show otherwise.

The fact that the claim on subject line is false is not a truism.
In order to determine the claim is false one needs some knowledge
that is not obvious.

When you try to show the steps attempting to show that
it is false I will point out the error.

Step 1: Find people who know C.
Step 2: Show them DD of OP and ask.

This is the only topic that I will discuss and any

typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   HHH(DD);
}
DD  correctly simulated by HHH cannot possibly terminate normally.

That claim has already shown to be false. Nothing above shows that
HHH does not return 0. If it does DD also returns 0.

*You (and everyone else) is proven wrong by the following*

918-1156 // All of the lines of termination analyzer HHH
1355-1370 // DD() through main()

https://github.com/plolcott/x86utm/blob/master/Halt7.c

The assembly language source code of every function in Halt7.c
https://github.com/plolcott/x86utm/blob/master/Halt7out.txt

This shows the complete execution trace of
(a) main
(b) DD

It does not show the 171 pages of execution trace of HHH.
This can be much more easily verified by the provided
239 lines of source code: 918-1156

Although the code for HHH is very difficult to understand
(Only Mike has ever really tried to understand it)
At least now it is all in one single contiguous block.

The x86utm operating system functions that it calls
are found here:
https://github.com/plolcott/x86utm/blob/master/x86utm.cpp

https://github.com/plolcott/x86utm/blob/master/include/Read_COFF_Object.h

[olcott]

Of course not. However, the fact that no reference to that
article before or when HHH

That paper and its code are the only thing that I have been
talking about in this forum for several years.

Doesn't matter when you don't say that you are talking about that
paper.
Anyway, that is irrelevant to the fact that the subject line
contains a false claim.

It is a truism and not one person on the face of the Earth can
possibly show otherwise.

The fact that the claim on subject line is false is not a truism.
In order to determine the claim is false one needs some knowledge
that is not obvious.

When you try to show the steps attempting to show that it is false I
will point out the error.

We havm, but you are too stupid to understand it.
Since when DD run, it halts,

THAT IS A DIFFERENT INSTANCE

Why are you passing the wrong input to HHH?

I will begin ignoring insincere replies.

Yes, please shut up.
But why are you not passing the same instance to HHH?

The first instance of recursion is not exactly the same as subsequent
instances of the exact same sequence of recursive invocations.

It is the same with recursive simulations. When the second recursive
invocation has been aborted the first one terminates normally misleading
people into believing that the recursive chain terminates normally.

[olcott]

Post by olcott

Of course not. However, the fact that no reference to that
article before or when HHH

That paper and its code are the only thing that I have been
talking about in this forum for several years.

Doesn't matter when you don't say that you are talking
about that
paper.
Anyway, that is irrelevant to the fact that the subject line
contains a false claim.

It is a truism and not one person on the face of the Earth can
possibly show otherwise.

The fact that the claim on subject line is false is not a
truism.
In order to determine the claim is false one needs some
knowledge
that is not obvious.

When you try to show the steps attempting to show that it is
false I
will point out the error.

Step 1: Find people who know C.
Step 2: Show them DD of OP and ask.

This is the only topic that I will discuss and any

typedef void (*ptr)();
int HHH(ptr P);
int DD()
{
    int Halt_Status = HHH(DD);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    HHH(DD);
}
DD  correctly simulated by HHH cannot possibly terminate normally.

That claim has already shown to be false. Nothing above shows
that HHH
does not return 0. If it does DD also returns 0.

When we are referring to the above DD simulated by HHH and not
trying to
get away with changing the subject to some other DD somewhere else

such as one that calls a non-aborting version of HHH

then
anyone with sufficient knowledge of C programming knows that no
instance
of DD shown above simulated by any corresponding instance of HHH can
possibly terminate normally.

Well, then that corresponding (by what?) HHH isn’t a decider.

Technically a decider is any TM that always stops running.
https://en.wikipedia.org/wiki/Decider_(Turing_machine)
I am focusing on the isomorphic notion of a termination analyzer.
A simulating termination analyzer correctly rejects any input
that must be aborted to prevent its own non-termination.

Right, but the answer given by the decider must match the problem.

Any divergence from the above specification is stipulated
to be incorrect.

In other words, you are ADMITTING you have no idea of the actual
problem, and think people are interested in your strawman.
The WORLD will reject any divergence from the actual specification,
leaving you out in the dark just admitting you are a moron.

*This is the pathological input termination analyzer problem*
Some people might see this as isomorphic to other problems
and some people may not see this.

In other words, you are just now admitting you have been LYING for
decades, because you were too stupid to understand what you were
claiming you were working.
Glad you finally admitted it.
The POOP theory is admitted to be just a pile of shit that you made up,
and says NOTHING about the real Halting Problem that you are admitting
is too "complecated" for you to undetstand.
Sorry, that is the facts of what you just said.

I am stipulating that I have solved the simulating
termination analyzer pathological input problem.

Some people will see a remarkable similarity to the
halting problem proofs, and some will not.

[olcott]

[ .... ]

I have given everyone here all of the complete source code for a few
years

True but irrelevant. OP did not specify that HHH means that particular
code.

Every post that I have been talking about for two or
more years has referred to variations of that same code.

Yes. It would be a relief if you could move on to posting something new
and fresh.

As soon as people fully address rather than endlessly dodge
my key points I will be done.

Let's start with a root point.
All of the other points validate this root point.

*Simulating termination analyzer HHH correctly determines*
*the non-halt status of DD*

*According to the UTPTO patent law practice I am incorporating*
*the following paper and source-code by reference*
https://www.uspto.gov/web/offices/pac/mpep/s217.html

Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D


918-1156 // All of the lines of termination analyzer HHH
1355-1370 // DD() through main()

https://github.com/plolcott/x86utm/blob/master/Halt7.c

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

[olcott]

[ .... ]

I have given everyone here all of the complete source code for a few
years

True but irrelevant. OP did not specify that HHH means that particular
code.

Every post that I have been talking about for two or
more years has referred to variations of that same code.

Yes. It would be a relief if you could move on to posting something new
and fresh.

As soon as people fully address rather than endlessly dodge
my key points I will be done.

Let's start with a root point.
All of the other points validate this root point.

*Simulating termination analyzer HHH correctly determines*
*the non-halt status of DD*

*According to the UTPTO patent law practice I am incorporating*
*the following paper and source-code by reference*
https://www.uspto.gov/web/offices/pac/mpep/s217.html

Simulating Termination Analyzer H is Not Fooled by Pathological Input D
https://www.researchgate.net/publication/369971402_Simulating_Termination_Analyzer_H_is_Not_Fooled_by_Pathological_Input_D


918-1156 // All of the lines of termination analyzer HHH
1355-1370 // DD() through main()

https://github.com/plolcott/x86utm/blob/master/Halt7.c

--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer