Re: D correctly simulated by H remains stuck in recursive simulation

On Wed, 2024-05-22 at 10:44 -0500, olcott wrote:

On 5/22/2024 3:54 AM, David Brown wrote:

On 21/05/2024 23:56, olcott wrote:

On 5/21/2024 4:34 PM, bart wrote:

On 21/05/2024 19:48, olcott wrote:

On 5/21/2024 1:39 PM, Bonita Montero wrote:

 

You're neither asking about a C- or C++ problem.
So use a proper newsgroup.
 

 
There is no other group that knows enough about the semantics of the
C programming language and there is no other group still alive that
knows enough about the semantics of programming languages.

 
Then FFS take it to Reddit, where there are a myriad thriving forums,
rather than a dying usenet group populated by a few aging regulars.
 
 

 
I have taken it to many different forums.
This is one of two forums where someone actually answered the question.
Two years ago someone answered the assembly language version of the
question. I think the Reddit banned me for even asking the question.
 

 
The /only/ reason you are not banned here is because unmoderated Usenet
groups cannot ban people.
 
You post obsessively in many places, and face nothing but rejection,
ridicule, and banning.  Has it ever occurred to you to look for the
common factor here?  It is /you/, and the posts you make.  If you truly
want to make progress on your bizarre ideas, you are going to have to
re-think your strategy - it is entirely obvious to everyone that you
will not get the answers you are asking for here or anywhere else with
your current posting style.
 
 

 
*On the other hand people could simply answer my question*
*I only repeat it until it is answered*
 
For every H/D pair matching the following template where
H is a pure function:
 
Does any D correctly simulated by H reach its own line 06 and
halt or does the fact that D remains stuck in recursive simulation
prevent that?
 
typedef int (*ptr)();  // ptr is pointer to int function in C
00       int H(ptr p, ptr i);
01       int D(ptr p)
02       {
03         int Halt_Status = H(p, p);
04         if (Halt_Status)
05           HERE: goto HERE;
06         return Halt_Status;
07       }
08
09       int main()
10       {
11         H(D,D);
12         return 0;
13       }
 
It is trivial to see that for every H/D pair of the infinite
set of H/D pairs that match the above template that
 
D correctly simulated by H cannot possibly reach its own final
state at line 06 and halt because D correctly simulated by
H remains stuck in recursive simulation.
 
This provides the basis for simulating termination analyzer H to
correctly determine that the halting problem's counter-example
input D cannot possibly halt.
 

If H is truly a simulator, its function is expected to be equivalent to:

int H(ptr x, ptr y) {
 x(y);
 return __WHATEVER;
}

The H(D,D) can never halt.