Discussion:
D correctly simulated by pure function H remains stuck in recursive simulation s
(too old to reply)
olcott
2024-05-22 13:57:56 UTC
Permalink
Because D correctly simulated by pure function H remains stuck in
recursive simulation simulating termination analyzer H is correct
to report that D does not halt.

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.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Bonita Montero
2024-05-22 16:31:22 UTC
Permalink
Post by olcott
Because D correctly simulated by pure function H remains stuck in
recursive simulation simulating termination analyzer H is correct
to report that D does not halt.
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.
Ok, then every question is answered and we could proceed to
"sth. completely different" (Monty Python).
olcott
2024-05-22 19:57:44 UTC
Permalink
Post by Bonita Montero
Post by olcott
Because D correctly simulated by pure function H remains stuck in
recursive simulation simulating termination analyzer H is correct
to report that D does not halt.
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.
Ok, then every question is answered and we could proceed to
"sth. completely different" (Monty Python).
*No this question has never been answered in this forum*
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Bonita Montero
2024-05-22 20:09:28 UTC
Permalink
Post by olcott
Post by Bonita Montero
Post by olcott
Because D correctly simulated by pure function H remains stuck in
recursive simulation simulating termination analyzer H is correct
to report that D does not halt.
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.
Ok, then every question is answered and we could proceed to
"sth. completely different" (Monty Python).
*No this question has never been answered in this forum*
Because this question is about C++ and not theoretical computer
sciences. And even if you'd get an answer: you wouldn't recoginze
it because you're unable to see that you're asking nonsense.
olcott
2024-05-22 20:17:22 UTC
Permalink
Post by Bonita Montero
Post by olcott
Post by Bonita Montero
Post by olcott
Because D correctly simulated by pure function H remains stuck in
recursive simulation simulating termination analyzer H is correct
to report that D does not halt.
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.
Ok, then every question is answered and we could proceed to
"sth. completely different" (Monty Python).
*No this question has never been answered in this forum*
Because this question is about C++ and not theoretical computer
sciences. And even if you'd get an answer: you wouldn't recoginze
it because you're unable to see that you're asking nonsense.
One person took thirty seconds to answer the question.
If you want to post hundreds and hundreds of messages
saying that you don't want to spend 30 seconds to answer
the question feel free.

I only need three correct answers from three people and
the question is sufficiently answered and I am back out
of here.

I was thinking about offering a $10 cash reward for the
first person that finds a valid counter-example.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Chris M. Thomasson
2024-05-22 21:36:39 UTC
Permalink
[...]
Post by Bonita Montero
Post by olcott
*No this question has never been answered in this forum*
Because this question is about C++ and not theoretical computer
sciences. And even if you'd get an answer: you wouldn't recoginze
it because you're unable to see that you're asking nonsense.
Ditto.
olcott
2024-05-22 21:45:13 UTC
Permalink
Post by Bonita Montero
Post by olcott
Post by Bonita Montero
Post by olcott
Because D correctly simulated by pure function H remains stuck in
recursive simulation simulating termination analyzer H is correct
to report that D does not halt.
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.
Ok, then every question is answered and we could proceed to
"sth. completely different" (Monty Python).
*No this question has never been answered in this forum*
Because this question is about C++ and not theoretical computer
sciences.
<snip pure denigration / ad hominem>

My question is ONLY about the semantics of the above c17 code and
what behavior that this semantics entails. I don't want or need
any answer outside of this scope in this forum.

The people in other forums have proven to be incompetent about the
behavior specified by the above c17 code.
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
Loading...