Can someone please verify the execution trace of this?

Post by olcott
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
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 }
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)

But since you have defined that H WILL abort, that is irrelevant.

Post by olcott
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
The key thing to note is that no D correctly simulated by any H of every
H/D pair specified by the above template ever reaches its own line 06
and halts.

Without defining what H is, you can't define what the simulation is.

You are just showing that you don't understand what you are talking about.

Sam

2024-05-19 01:12:39 UTC

This does not conform to any version of C or C++. This looks like a weird
hybrid of C and BASIC, where each line of code is prepended with a numeric
line number.

olcott

2024-05-19 03:16:18 UTC

This does not conform to any version of C or C++. This looks like a
weird hybrid of C and BASIC, where each line of code is prepended with a
numeric line number.

I added the line numbers so that I could describe the execution
trace. It compiles under Microsoft with these flags:

cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c

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

jak

2024-05-19 04:24:04 UTC

This does not conform to any version of C or C++. This looks like a
weird hybrid of C and BASIC, where each line of code is prepended with
a numeric line number.

I added the line numbers so that I could describe the execution
cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c

Please don't answer the trolls. He had to cut a part of your post in
order to justify his useless message.

Bonita Montero

2024-05-19 18:08:46 UTC

Other people think 30s about this, you think years about that.

olcott

2024-05-19 19:00:15 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.

*I have only gotten truthful answers on 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

Richard Damon

2024-05-19 19:24:27 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

And I did show an H that can do that.

When you try to add requirements that outlaw my version, it makes the
logic that you version uses clearly incorrect, so you are stuck.

Bonita Montero

2024-05-20 01:52:46 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

olcott

2024-05-20 02:43:06 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.

I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

--
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-20 05:09:44 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.

olcott

2024-05-20 05:38:47 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.

It would take three people five minutes a piece.
Then I can go back to the other forum.

They have been lying about how the above code works
consistently for two years. I know how it works. I
learned C back when K & R was the standard.

Three people take five minutes a piece to confirm the
that the last sentence is correct.

typedef int (*ptr)(); // ptr is pointer to int function
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 }

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.

This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

Execution Trace
Line 11: main() invokes H(D,D);

keeps repeating (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Simulation invariant:
D correctly simulated by H cannot possibly reach past its own line 03.

H must be a pure function
https://en.wikipedia.org/wiki/Pure_function#

*THIS ONE SENTENCE NEEDS TO BE CONFIRMED*
For every H/D pair of the above template D correctly simulated
by H cannot possibly reach its own final state at line 06 and 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-20 06:41:52 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.

It would take three people five minutes a piece.
Then I can go back to the other forum.
They have been lying about how the above code works
consistently for two years. I know how it works. I
learned C back when K & R was the standard.
Three people take five minutes a piece to confirm the
that the last sentence is correct.
typedef int (*ptr)(); // ptr is pointer to int function
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 }
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
Execution Trace
Line 11: main() invokes H(D,D);
keeps repeating (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
D correctly simulated by H cannot possibly reach past its own line 03.
H must be a pure function
https://en.wikipedia.org/wiki/Pure_function#
*THIS ONE SENTENCE NEEDS TO BE CONFIRMED*
For every H/D pair of the above template D correctly simulated
by H cannot possibly reach its own final state at line 06 and halt.

You're dealing with things no one is concerned about.

olcott

2024-05-20 14:47:53 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.

It would take three people five minutes a piece.
Then I can go back to the other forum.
They have been lying about how the above code works
consistently for two years. I know how it works. I
learned C back when K & R was the standard.
Three people take five minutes a piece to confirm the
that the last sentence is correct.
typedef int (*ptr)(); // ptr is pointer to int function
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 }
In the above case a simulator is an x86 emulator that correctly
emulates at least one of the x86 instructions of D in the order
specified by the x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
Execution Trace
Line 11: main() invokes H(D,D);
keeps repeating (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
D correctly simulated by H cannot possibly reach past its own line 03.
H must be a pure function
https://en.wikipedia.org/wiki/Pure_function#
*THIS ONE SENTENCE NEEDS TO BE CONFIRMED*
For every H/D pair of the above template D correctly simulated
by H cannot possibly reach its own final state at line 06 and halt.

You're dealing with things no one is concerned about.

It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

--
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-20 15:16:39 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

olcott

2024-05-20 16:01:00 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

--
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-20 17:15:29 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

olcott

2024-05-20 17:20:12 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
keep ignoring it has nothing to do will my circles:
Ask until answered stops when answered.

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

Richard Harnden

2024-05-20 18:26:21 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

You haven't improved on: https://xkcd.com/1266/

olcott

2024-05-20 19:09:10 UTC

Post by Richard Harnden

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

You haven't improved on: https://xkcd.com/1266/

I have and several PhD computer scientists agree. This
is not the place to discuss that.

--
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-20 18:35:24 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program. You do not know
it its going to halt or not. It could run forever, or get into a
scenario where it might halt in say, 42 years of constant running. Your
decider erroneously says it does not halt, but it does.

olcott

2024-05-20 19:15:11 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

typedef int (*ptr)(); // ptr is pointer to int function
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 }

Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

*In this group I only need that last line verified*

Post by Chris M. Thomasson
You do not know
it its going to halt or not. It could run forever, or get into a
scenario where it might halt in say, 42 years of constant running. Your
decider erroneously says it does not halt, but it does.

--
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-20 19:23:25 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]

Humm... So, what is your main point? You cannot decide if a program will
halt, _unless_ you code the test program?

olcott

2024-05-20 19:28:02 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program will
halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

--
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-20 19:30:13 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

olcott

2024-05-20 19:34:18 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.
D is fully specified and the only relevant detail about H is that

it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.

*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 19:35:39 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.

Why not?

Post by olcott
D is fully specified and the only relevant detail about H is that
it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.
*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

Chris M. Thomasson

2024-05-20 19:36:51 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.
D is fully specified and the only relevant detail about H is that
it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.

How do you simulate to infinity, and perhaps beyond?

Post by olcott
*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

olcott

2024-05-20 19:38:38 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.
D is fully specified and the only relevant detail about H is that
it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.

How do you simulate to infinity, and perhaps beyond?

The Turing machine isomorphism of the H/D pair is off-topic
for this group.

Post by olcott
*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 19:42:51 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a
program will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.
D is fully specified and the only relevant detail about H is that
it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.

How do you simulate to infinity, and perhaps beyond?

The Turing machine isomorphism of the H/D pair is off-topic
for this group.

Why?

Post by olcott
*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

Chris M. Thomasson

2024-05-20 19:38:47 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.
D is fully specified and the only relevant detail about H is that
it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.
*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

So, your thing will tell me if a program XYZ will halt or not only
_after_ it simulates to infinity? What am I missing here?

olcott

2024-05-20 19:40:32 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

My ONLY point has been to put the people that have continued to
lie about the behavior of D correctly simulated by H in their place.
Several people have consistently lied about this for two years.

My only point is that one cannot 100% totally decide if a black box
program will halt, or not.

I am not asking about any black box program.
D is fully specified and the only relevant detail about H is that
it correctly simulates 1 to ∞ steps of D thus including 0 to ∞
recursive simulations of H simulating itself simulating D.
*From this we can conclude*
*D correctly simulated by H never reaches its own line 06 and halts*

So, your thing will tell me if a program XYZ will halt or not only
_after_ it simulates to infinity? What am I missing here?

*The 100% totally complete every single detail scope of my post*
*The 100% totally complete every single detail scope of my post*
*The 100% totally complete every single detail scope of my post*

typedef int (*ptr)(); // ptr is pointer to int function
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 }

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.

This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

Execution Trace
Line 11: main() invokes H(D,D);

keeps repeating (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Simulation invariant:
D correctly simulated by H cannot possibly reach past its own line 03.

For every H/D pair of the above template D correctly simulated by pure
function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

--
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-20 19:44:12 UTC

[...]

Post by Chris M. Thomasson
So, your thing will tell me if a program XYZ will halt or not only
_after_ it simulates to infinity? What am I missing here?

Define H?

olcott

2024-05-20 19:48:44 UTC

Post by Chris M. Thomasson
So, your thing will tell me if a program XYZ will halt or not only
_after_ it simulates to infinity? What am I missing here?

Define H?

I have two fully operational examples of H that have been fully
operational for years. I am not talking about those. I am only
talking this:

typedef int (*ptr)(); // ptr is pointer to int function
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 }

Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 19:50:03 UTC

Post by Chris M. Thomasson
So, your thing will tell me if a program XYZ will halt or not only
_after_ it simulates to infinity? What am I missing here?

Define H?

I have two fully operational examples of H that have been fully
operational for years. I am not talking about those. I am only
typedef int (*ptr)(); // ptr is pointer to int function
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 }
Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

Can I create a program that your simulator will correctly say, halts or
not? If so, how? How does your simulator call into my program? Where do
I begin execution?

Chris M. Thomasson

2024-05-20 19:52:13 UTC

Post by Chris M. Thomasson
So, your thing will tell me if a program XYZ will halt or not only
_after_ it simulates to infinity? What am I missing here?

Define H?

Can I create a program that your simulator will correctly say, halts or
not? If so, how? How does your simulator call into my program? Where do
I begin execution?

So, I can define H? Because it looks like a function pointer.

Chris M. Thomasson

2024-05-20 19:32:18 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program will
halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call into a
TRNG or something? Create a race condition on purpose? Check this out:

https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

olcott

2024-05-20 19:37:03 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call into a
https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.

I can do this at the Turing Machine level too, yet off-topic
for this group.

--
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-20 19:41:03 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call into a
https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.
I can do this at the Turing Machine level too, yet off-topic
for this group.

So, you do not care if the halting problem can be applied to a "black
box" program? What am I missing here? I must be missing something
important, right?

olcott

2024-05-20 19:45:41 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call into a
https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.
I can do this at the Turing Machine level too, yet off-topic
for this group.

So, you do not care if the halting problem can be applied to a "black
box" program? What am I missing here? I must be missing something
important, right?

I do not want to discuss things that are off-topic for this
group. I don't want to discuss anything with anyone until
after my claim about the execution trace has been validated.

I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.

Enlarge the category a tiny little bit and then the time
becomes infeasible.

THIS IS THE CATEGORY
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 19:47:06 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a program
will halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call into
a TRNG or something? Create a race condition on purpose? Check this
https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.
I can do this at the Turing Machine level too, yet off-topic
for this group.

So, you do not care if the halting problem can be applied to a "black
box" program? What am I missing here? I must be missing something
important, right?

I do not want to discuss things that are off-topic for this
group. I don't want to discuss anything with anyone until
after my claim about the execution trace has been validated.
I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.
Enlarge the category a tiny little bit and then the time
becomes infeasible.
THIS IS THE CATEGORY
*D correctly simulated by H never reaches its own line 06 and halts*

How can I create a program that runs in your simulator?

olcott

2024-05-20 19:53:35 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a
program will halt, _unless_ you code the test program?

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.
I can do this at the Turing Machine level too, yet off-topic
for this group.

So, you do not care if the halting problem can be applied to a "black
box" program? What am I missing here? I must be missing something
important, right?

I do not want to discuss things that are off-topic for this
group. I don't want to discuss anything with anyone until
after my claim about the execution trace has been validated.
I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.
Enlarge the category a tiny little bit and then the time
becomes infeasible.
THIS IS THE CATEGORY
*D correctly simulated by H never reaches its own line 06 and halts*

How can I create a program that runs in your simulator?

That is another different category of question.

If I was not diagnosed with POD24 and instead was 100% totally
immortal I could not tolerate the change-the-subject rebuttal
and prove my point in finite time.

*Validation of POD24 as a robust early clinical end point of*
*poor survival in FL from 5225 patients on 13 clinical trials*
https://pubmed.ncbi.nlm.nih.gov/34614146/

--
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-20 20:04:57 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a
program will halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call
into a TRNG or something? Create a race condition on purpose?
https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.
I can do this at the Turing Machine level too, yet off-topic
for this group.

So, you do not care if the halting problem can be applied to a
"black box" program? What am I missing here? I must be missing
something important, right?

I do not want to discuss things that are off-topic for this
group. I don't want to discuss anything with anyone until
after my claim about the execution trace has been validated.
I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.
Enlarge the category a tiny little bit and then the time
becomes infeasible.
THIS IS THE CATEGORY
*D correctly simulated by H never reaches its own line 06 and halts*

How can I create a program that runs in your simulator?

That is another different category of question.

It's been a while since I have used x86 assembly language. But, I can
get back into it, if needed... Here is some of my older code:

https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

Post by olcott
If I was not diagnosed with POD24 and instead was 100% totally
immortal I could not tolerate the change-the-subject rebuttal
and prove my point in finite time.
*Validation of POD24 as a robust early clinical end point of*
*poor survival in FL from 5225 patients on 13 clinical trials*
https://pubmed.ncbi.nlm.nih.gov/34614146/

olcott

2024-05-20 20:10:42 UTC

Post by olcott
It is a simple question about the behavior of C functions.
This group's purpose is the C/C++ language.

Your question is generic to most languages and you're
not asking how to do that in C or how to improve that.
And you're asking the same thing for years.

Yes I am very persistent. I keep asking until
I get an answer.

After some time you should recognize you're doing circles.

I am asking a straight forward question that people
Ask until answered stops when answered.

Think of your halt decider running a black box program.

*It is not even a halt decider in this post it is merely a simulator*

[...]
Humm... So, what is your main point? You cannot decide if a
program will halt, _unless_ you code the test program?

Can I create a program that runs in your simulator? Can I call
into a TRNG or something? Create a race condition on purpose?
https://groups.google.com/g/comp.lang.c++/c/7u_rLgQe86k/m/fYU9SnuAFQAJ

The entire scope of my 20 year primary research only has
the scope of the conventional HP counter-example inputs.
I can do this at the Turing Machine level too, yet off-topic
for this group.

So, you do not care if the halting problem can be applied to a
"black box" program? What am I missing here? I must be missing
something important, right?

I do not want to discuss things that are off-topic for this
group. I don't want to discuss anything with anyone until
after my claim about the execution trace has been validated.
I am using categorically exhaustive reasoning that can work
through every possibility that can possibly exist in a feasible
amount of time as long as the category is very very narrow.
Enlarge the category a tiny little bit and then the time
becomes infeasible.
THIS IS THE CATEGORY
*D correctly simulated by H never reaches its own line 06 and halts*

How can I create a program that runs in your simulator?

That is another different category of question.

It's been a while since I have used x86 assembly language. But, I can
https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

I found out that almost everyone is totally clueless about
assembly language and that is why it is so important that
credible experts confirm what I already know:

typedef int (*ptr)(); // ptr is pointer to int function
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 }

Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 20:19:37 UTC

[...]

Post by Chris M. Thomasson
How can I create a program that runs in your simulator?

That is another different category of question.

It's been a while since I have used x86 assembly language. But, I can
https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

I found out that almost everyone is totally clueless about
assembly language and that is why it is so important that

[...]

So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I am
interested on how you simulate the cmpxchg8b and/or the cmpxchg16b
functions?

Chris M. Thomasson

2024-05-20 20:21:34 UTC

Post by Chris M. Thomasson
How can I create a program that runs in your simulator?

That is another different category of question.

It's been a while since I have used x86 assembly language. But, I can
https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

I found out that almost everyone is totally clueless about
assembly language and that is why it is so important that

[...]
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I am
interested on how you simulate the cmpxchg8b and/or the cmpxchg16b
functions?

Fwiw, I found some issues in a C compiler, Pelles C:

https://forum.pellesc.de/index.php?topic=7311.msg27764#msg27764

https://forum.pellesc.de/index.php?topic=7167.msg27217#msg27217
(read all)

olcott

2024-05-20 20:30:30 UTC

Post by Chris M. Thomasson
How can I create a program that runs in your simulator?

That is another different category of question.

It's been a while since I have used x86 assembly language. But, I can
https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

I found out that almost everyone is totally clueless about
assembly language and that is why it is so important that

[...]
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I am
interested on how you simulate the cmpxchg8b and/or the cmpxchg16b
functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Please get back to the behavior of D correctly simulated by H.
My recent surgery cut short the time that I need to do essential
household chores. When they put me on the experimental medication
that they use for POD24 cases I may be too weak to do stuff that
must be done.

--
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-20 20:31:43 UTC

Post by Chris M. Thomasson
How can I create a program that runs in your simulator?

That is another different category of question.

It's been a while since I have used x86 assembly language. But, I
https://web.archive.org/web/20060214112539/http://appcore.home.comcast.net/appcore/src/cpu/i686/ac_i686_masm_asm.html

I found out that almost everyone is totally clueless about
assembly language and that is why it is so important that

[...]
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I am
interested on how you simulate the cmpxchg8b and/or the cmpxchg16b
functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

Post by olcott
Please get back to the behavior of D correctly simulated by H.
My recent surgery cut short the time that I need to do essential
household chores. When they put me on the experimental medication
that they use for POD24 cases I may be too weak to do stuff that
must be done.

Chris M. Thomasson

2024-05-20 20:32:57 UTC

[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I am
interested on how you simulate the cmpxchg8b and/or the cmpxchg16b
functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

[...]

I notice this:

typedef int (*ptr)(); // ptr is pointer to int function
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 }

But, where is H?

olcott

2024-05-20 20:36:29 UTC

Post by olcott
[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I
am interested on how you simulate the cmpxchg8b and/or the
cmpxchg16b functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

[...]
typedef int (*ptr)(); // ptr is pointer to int function
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 }
But, where is H?

*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 20:38:07 UTC

Post by olcott
[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I
am interested on how you simulate the cmpxchg8b and/or the
cmpxchg16b functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

I still cannot find even a simple example definition of H.

Post by olcott
Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

olcott

2024-05-20 20:52:02 UTC

Post by olcott
[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw, I
am interested on how you simulate the cmpxchg8b and/or the
cmpxchg16b functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

I still cannot find even a simple example definition of H.

THIS IS 100% OF ALL OF THE REQUIREMENTS FOR H
H correctly simulates D with an x86 emulator.
everything else about H is wide open.

H plays a game of tic-tac-toe and then
H correctly simulates D with an x86 emulator.

Have you ever heard of infinite sets?
Of everyone in the world that has a mole
exactly where is this mole on their body?

--
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-20 21:05:01 UTC

Post by olcott
[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw,
I am interested on how you simulate the cmpxchg8b and/or the
cmpxchg16b functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

I still cannot find even a simple example definition of H.

THIS IS 100% OF ALL OF THE REQUIREMENTS FOR H
H correctly simulates D with an x86 emulator.
everything else about H is wide open.
H plays a game of tic-tac-toe and then
H correctly simulates D with an x86 emulator.
Have you ever heard of infinite sets?

Ever heard of the natural numbers?

Post by olcott
Of everyone in the world that has a mole
exactly where is this mole on their body?

So, are you creating a halt decider that is correct or not? If not,
what's the damn point?

Post by olcott
Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including

So, it can simulate to infinity, then tell you an answer?

Post by olcott
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

Chris M. Thomasson

2024-05-20 21:09:33 UTC

Post by olcott
[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw,
I am interested on how you simulate the cmpxchg8b and/or the
cmpxchg16b functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

I still cannot find even a simple example definition of H.

THIS IS 100% OF ALL OF THE REQUIREMENTS FOR H
H correctly simulates D with an x86 emulator.
everything else about H is wide open.
H plays a game of tic-tac-toe and then
H correctly simulates D with an x86 emulator.
Have you ever heard of infinite sets?

Ever heard of the natural numbers?

Post by olcott
Of everyone in the world that has a mole
exactly where is this mole on their body?

So, are you creating a halt decider that is correct or not? If not,
what's the damn point?

Post by olcott
Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including

So, it can simulate to infinity, then tell you an answer?

You should consult these guys. The first encyclopedia of all numbers!

Post by olcott
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

olcott

2024-05-20 21:27:57 UTC

Post by olcott
[...]

Post by Chris M. Thomasson
So, you created a simulator for x86? 32-bit I am assuming. Fwiw,
I am interested on how you simulate the cmpxchg8b and/or the
cmpxchg16b functions?

I use libx86emu providing an interface so that any C function
can simulate any other C function in debug step mode. The
original H can even simulated itself simulating P.

Can you show me a sample H? Is H a little program?

*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

I still cannot find even a simple example definition of H.

THIS IS 100% OF ALL OF THE REQUIREMENTS FOR H
H correctly simulates D with an x86 emulator.
everything else about H is wide open.
H plays a game of tic-tac-toe and then
H correctly simulates D with an x86 emulator.
Have you ever heard of infinite sets?

Ever heard of the natural numbers?

Post by olcott
Of everyone in the world that has a mole
exactly where is this mole on their body?

So, are you creating a halt decider that is correct or not? If not,
what's the damn point?

typedef int (*ptr)(); // ptr is pointer to int function
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 }

The ONLY point of this thread is that no D correctly simulated
by any H of the set of H/D pairs matching the above template
can possibly reach its own line 06 and halt.

Another different thread an another different forum can
discuss theory of computation issues.

Post by olcott
Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including

So, it can simulate to infinity, then tell you an answer?

Post by olcott
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

--
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-20 20:48:06 UTC

On 5/20/2024 1:36 PM, olcott wrote:
[...]

Post by olcott
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*
*IF YOU NEED TO RE0READ THIS 500 TIMES TO GET IT PLEASE DO*

[...]

Well, your C program needs H to be defined:
______________________
typedef int (*ptr)(); // ptr is pointer to int function

int H(ptr x, ptr y);

int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
H(D,D);
return 0;
}
______________________

Just on an online C compiler:

/rbin/ld: /tmp/ccWEmrz1.o: in function `D':
rJgigMp7Qh.c:(.text+0x1b): undefined reference to `H'
/rbin/ld: /tmp/ccWEmrz1.o: in function `main':
rJgigMp7Qh.c:(.text+0x3f): undefined reference to `H'
ERROR!
collect2: error: ld returned 1 exit status

So, what you going on about?

Fred. Zwarts

2024-05-20 08:10:32 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.

It would take three people five minutes a piece.
Then I can go back to the other forum.
They have been lying about how the above code works
consistently for two years. I know how it works. I
learned C back when K & R was the standard.
Three people take five minutes a piece to confirm the
that the last sentence is correct.
typedef int (*ptr)(); // ptr is pointer to int function
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 }
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
Execution Trace
Line 11: main() invokes H(D,D);
keeps repeating (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
D correctly simulated by H cannot possibly reach past its own line 03.
H must be a pure function
https://en.wikipedia.org/wiki/Pure_function#
*THIS ONE SENTENCE NEEDS TO BE CONFIRMED*
For every H/D pair of the above template D correctly simulated
by H cannot possibly reach its own final state at line 06 and halt.

Olcott cannot find a proof for his claim. Now he tries a proof by
authority. He is looking for persons with some authority to support him.
But such a proof does not depend on the number and the expertise of
witnesses, as is common for a juridical proof. In computation theory a
proof consists of logic steps.

olcott

2024-05-20 14:51:14 UTC

Post by Fred. Zwarts

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

You ask the same questions over and over again for years.
It's like circling your thoughts before you fall asleep -
you don't think about whether it really makes sense.

It would take three people five minutes a piece.
Then I can go back to the other forum.
They have been lying about how the above code works
consistently for two years. I know how it works. I
learned C back when K & R was the standard.
Three people take five minutes a piece to confirm the
that the last sentence is correct.
typedef int (*ptr)(); // ptr is pointer to int function
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 }
In the above case a simulator is an x86 emulator that correctly
emulates at least one of the x86 instructions of D in the order
specified by the x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
Execution Trace
Line 11: main() invokes H(D,D);
keeps repeating (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
D correctly simulated by H cannot possibly reach past its own line 03.
H must be a pure function
https://en.wikipedia.org/wiki/Pure_function#
*THIS ONE SENTENCE NEEDS TO BE CONFIRMED*
For every H/D pair of the above template D correctly simulated
by H cannot possibly reach its own final state at line 06 and halt.

Anyone having sufficient knowledge of the semantics
knows the answer. Likewise for these C functions:

void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}

int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}

void Infinite_Loop()
{
HERE: goto HERE;
}

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

Paavo Helde

2024-05-20 15:05:28 UTC

Post by olcott
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}

This one is tricky. Depending on the parameter value, implementation
capabilities and the optimizer quality it may either calculate something
(which would even be the correct factorial value, for sufficiently small
arguments) or cause an integer overflow or a stack overflow. These may
or may not terminate the program, depending on the compiler, runtime
environment and OS details.

olcott

2024-05-20 15:11:29 UTC

Post by Paavo Helde

Post by olcott
int factorial(int n)
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}

Good answer!

--
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-20 15:17:59 UTC

Post by olcott
Anyone having sufficient knowledge of the semantics
void Infinite_Recursion(u32 N)
{
Infinite_Recursion(N);
}
int factorial(int n)
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
void Infinite_Loop()
{
HERE: goto HERE;
}

I can't believe you're a professional developer when you repeatedly
run into the wall with simple questions like this for years.

olcott

2024-05-20 16:07:09 UTC

Post by olcott
Anyone having sufficient knowledge of the semantics
void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}
int factorial(int n)
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
void Infinite_Loop()
{
   HERE: goto HERE;
}

I can't believe you're a professional developer when you repeatedly
run into the wall with simple questions like this for years.

I have known the answer from an actual execution trace for years.
Anyone with sufficient knowledge of the semantics of the C language
knows the answer. *I just need several liars to be put in their place*

That P is correctly simulated by H is proven by the fact that
every assembly language instruction of P is correctly simulated
by H in the order specified by the x86 assembly language of P
even when H correctly simulates itself simulating P.

All of the details of this (except the 354 page execution
trace of H) are shown on pages 4-5 of the following paper.

*My 2021-09-26 09:39 AM paper*
*Halting problem undecidability and infinitely nested simulation*
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

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

Fred. Zwarts

2024-05-20 22:14:46 UTC

Post by olcott
Anyone having sufficient knowledge of the semantics
void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}
int factorial(int n)
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
void Infinite_Loop()
{
   HERE: goto HERE;
}

I can't believe you're a professional developer when you repeatedly
run into the wall with simple questions like this for years.

I have known the answer from an actual execution trace for years.

The actual execution trace of the infinite number of H/D pairs?

Post by olcott
Anyone with sufficient knowledge of the semantics of the C language
knows the answer. *I just need several liars to be put in their place*

Showing a proof for the claim would help more than finding somebody to
confirm the claim without evidence.

olcott

2024-05-20 22:23:07 UTC

Post by Fred. Zwarts

Post by olcott
Anyone having sufficient knowledge of the semantics
void Infinite_Recursion(u32 N)
{
   Infinite_Recursion(N);
}
int factorial(int n)
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
void Infinite_Loop()
{
   HERE: goto HERE;
}

I can't believe you're a professional developer when you repeatedly
run into the wall with simple questions like this for years.

I have known the answer from an actual execution trace for years.

The actual execution trace of the infinite number of H/D pairs?

Post by olcott
Anyone with sufficient knowledge of the semantics of the C language
knows the answer. *I just need several liars to be put in their place*

Showing a proof for the claim would help more than finding somebody to
confirm the claim without evidence.

The same way that my claim can be understood to be self-evidently
true that halt status of the following functions is self-evidently
true.

*Try and explain to the experts in this forum how no one can*
*possibly know that Infinite_Recursion() will not terminate normally*

void Infinite_Recursion()
{
Infinite_Recursion();
}

int factorial(int n) // on input 5
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}

void Infinite_Loop()
{
HERE: goto HERE;
}

void This_Halts()
{
return;
}

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

wij

2024-05-20 12:37:53 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

typedef int (*ptr)(); // ptr is pointer to int function
int H(ptr x, ptr y);
int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
H(D,D);
return 0;
}

The code above does not compile:
1. D does not fit the protocol H accepts --> After there years, you finally
learn to use typedef but still not seem to understand it.
2. H is not defined --> cannot compile to executable

You are trapped in an infinite recursive call.
You finally know it is an infinite recursive call. But the Halting Problem
asks for a program to answer the halting question, NOT YOU to answer the
question. According to GUR, even the H were your god, he neither can provide
the correct answer.

Besides, you just posted another proof that you lied again, fake false reports
of what you did and saw, hiding the actual result and tell what you like to
believe. Strictly, this is what all human may do, you are just too stupid.
The relevant part of your brain is burnt.

olcott

2024-05-20 15:02:29 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

*It does compile*
*It does compile*
*It does compile*
*It does compile*

typedef int (*ptr)();
int H(ptr P, ptr I);

int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
H(D,D);
return 0;
}

cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c
if ERRORLEVEL 1 pause

D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>echo
off

D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>REM
2022

D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>call
"C:\Program Files\Microsoft Visual
Studio\2022\Community\Common7\Tools\VsDevCmd.BAT"
**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.6.4
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.

Test_Compile.c
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.

Test_Compile.c
Press any key to continue . . .

Post by olcott
1. D does not fit the protocol H accepts --> After there years, you finally
learn to use typedef but still not seem to understand it.

That is false too. H has been fully implemented with
that protocol for a year.

Post by olcott
2. H is not defined --> cannot compile to executable

I am asking about the behavior of
every H/D pair of the above template D correctly simulated by pure
function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

Post by olcott
You are trapped in an infinite recursive call.
You finally know it is an infinite recursive call. But the Halting Problem
asks for a program to answer the halting question, NOT YOU to answer the
question. According to GUR, even the H were your god, he neither can provide
the correct answer.

This is a fully operational version from three years ago that
proves it does get the right answer on pages 4-5 of the paper.

*Quoted from page 4 of the paper linked below*
// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{
if (H(x, x))HERE:
goto HERE;
}

int main()
{
Output("Input_Halts = ", H((u32)P, (u32)P));
}

That P is correctly simulated by H is proven by the fact that
every assembly language instruction of P is correctly simulated
by H in the order specified by the x86 assembly language of P
even when H correctly simulates itself simulating P.

All of the details of this (except the 354 page execution
trace of H) are shown on pages 4-5 of the following paper.

*Halting problem undecidability and infinitely nested simulation*
https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

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

wij

2024-05-20 16:21:52 UTC

Post by olcott
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
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 }
In the above case a simulator is an x86 emulator that correctly
emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
The key thing to note is that no D correctly simulated by any H of
every
H/D pair specified by the above template ever reaches its own line 06
and halts.

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

*It does compile*
*It does compile*
*It does compile*
*It does compile*
typedef int (*ptr)();
int H(ptr P, ptr I);
int D(ptr x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   H(D,D);
   return 0;
}
cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c
if ERRORLEVEL 1 pause
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>echo
off
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>REM
2022
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>call
"C:\Program Files\Microsoft Visual
Studio\2022\Community\Common7\Tools\VsDevCmd.BAT"
**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.6.4
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Press any key to continue . . .

OK, My fault, gcc can compile (g++ can't. No idea why D's protocol doesn't match
type ptr and get compiled in C).

olcott

2024-05-20 17:23:55 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

*It does compile*
*It does compile*
*It does compile*
*It does compile*
typedef int (*ptr)();
int H(ptr P, ptr I);
int D(ptr x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   H(D,D);
   return 0;
}
cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c
if ERRORLEVEL 1 pause
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>echo
off
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>REM
2022
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>call
"C:\Program Files\Microsoft Visual
Studio\2022\Community\Common7\Tools\VsDevCmd.BAT"
**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.6.4
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Press any key to continue . . .

OK, My fault, gcc can compile (g++ can't. No idea why D's protocol doesn't match
type ptr and get compiled in C).

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.

This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

*I just need to people that have persistently lied*
*about this for two years to be put in their place*

*Can you see that*
For every H/D pair of the above template D correctly simulated by pure
function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

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

wij

2024-05-20 18:23:23 UTC

Post by olcott
People are saying that they have no idea what this code does
because they do not believe it conforms to c11 or c17.
typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03   int Halt_Status = H(x, x);
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 }
In the above case a simulator is an x86 emulator that correctly
emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*Execution Trace*
Line 11: main() invokes H(D,D);
*keeps repeating* (unless aborted)
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.
The key thing to note is that no D correctly simulated by any H of
every
H/D pair specified by the above template ever reaches its own line 06
and halts.

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

*It does compile*
*It does compile*
*It does compile*
*It does compile*
typedef int (*ptr)();
int H(ptr P, ptr I);
int D(ptr x)
{
    int Halt_Status = H(x, x);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    H(D,D);
    return 0;
}
cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c
if ERRORLEVEL 1 pause
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>echo
off
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>REM
2022
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>call
"C:\Program Files\Microsoft Visual
Studio\2022\Community\Common7\Tools\VsDevCmd.BAT"
**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.6.4
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Press any key to continue . . .

OK, My fault, gcc can compile (g++ can't. No idea why D's protocol doesn't match
type ptr and get compiled in C).

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*I just need to people that have persistently lied*
*about this for two years to be put in their place*
*Can you see that*
For every H/D pair of the above template D correctly simulated by pure
function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

People understand "H cannot possibly reach its own final state at line 06
and halt". People should be saying that your H cannot stop 'simulation' so as
to be called a simolation of D.
Your H surely can stop and make whatever decision, but since D is defined on
the behavior of H, D knows it, D will also change its behavior. This change
of behavior of D to behave differently can never be simulated and decided by H,
whatever H tries.

The logic is the same as the liar's paradox. H cannot return yes/no correctly.
All others are whatever you like to say, nothing to do with the HP. Godel,Sisper,Tarsky....

olcott

2024-05-20 19:07:52 UTC

Other people think 30s about this, you think years about that.

It is the basis for my two decades long primary research into
termination analysis. People on another forum have written
hundreds of posts claiming that D correctly simulated by H
reaches its own line 06 and halts.
*I have only gotten truthful answers on this forum*

That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

*It does compile*
*It does compile*
*It does compile*
*It does compile*
typedef int (*ptr)();
int H(ptr P, ptr I);
int D(ptr x)
{
    int Halt_Status = H(x, x);
    if (Halt_Status)
      HERE: goto HERE;
    return Halt_Status;
}
int main()
{
    H(D,D);
    return 0;
}
cl /GS- /std:c11 /c /arch:IA32 Test_Compile.c
cl /GS- /std:c17 /c /arch:IA32 Test_Compile.c
if ERRORLEVEL 1 pause
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>echo
off
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>REM
2022
D:\__HP_Stream\__NLU_Notes\__Work_In_Progress\__Halt_Decider_X86\___x86utm_VS>call
"C:\Program Files\Microsoft Visual
Studio\2022\Community\Common7\Tools\VsDevCmd.BAT"
**********************************************************************
** Visual Studio 2022 Developer Command Prompt v17.6.4
** Copyright (c) 2022 Microsoft Corporation
**********************************************************************
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Microsoft (R) C/C++ Optimizing Compiler Version 19.36.32535 for x86
Copyright (C) Microsoft Corporation. All rights reserved.
Test_Compile.c
Press any key to continue . . .

OK, My fault, gcc can compile (g++ can't. No idea why D's protocol doesn't match
type ptr and get compiled in C).

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.
*I just need to people that have persistently lied*
*about this for two years to be put in their place*
*Can you see that*
For every H/D pair of the above template D correctly simulated by pure
function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

People understand "H cannot possibly reach its own final state at line 06
and halt".

That is nothing like what I said.

Post by wij
People should be saying that your H cannot stop 'simulation' so as
to be called a simolation of D.

Every element of an infinite set of H/D pairs matching the above
template where H correctly simulates 1 to ∞ steps of D thus including
0 to ∞ recursive simulations of H simulating itself simulating D.
*D correctly simulated by H never reaches its own line 06 and halts*

Post by wij
Your H surely can stop and make whatever decision, but since D is defined on
the behavior of H, D knows it, D will also change its behavior. This change
of behavior of D to behave differently can never be simulated and decided by H,
whatever H tries.
The logic is the same as the liar's paradox. H cannot return yes/no correctly.
All others are whatever you like to say, nothing to do with the HP. Godel,Sisper,Tarsky....

You are correct that this is just like the Liar Paradox.
I have a way around this that cannot be discussed in a C/C++ forum.

comp.theory is my main forum for discussing this, those people
seem clueless of the semantics of C.

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

Keith Thompson

2024-05-21 02:23:00 UTC

wij <***@gmail.com> writes:
[...]

Post by olcott
typedef int (*ptr)(); // ptr is pointer to int function
int H(ptr x, ptr y);
int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D,D);
return 0;
}

Yes, it does (as you acknowledge in a later post).

This:
typedef int (*ptr)();
defines "ptr" as an alias for a type that can be described in English
as "pointer to function returning int". The empty parentheses
indicate that the function takes an unspecified but fixed number
and type(s) of arguments; this is an old-style declaration.

(The C23 standard, not yet released, changes the semantics of empty
parentheses, causing the code to be invalid, but let's assume C17.)

The function H is declared but not defined. That doesn't prevent
the code from being *compiled*, but it does prevent it from being
*linked* to produce an executable program. Perhaps a definition
of H has been presented in some other article, but I will not waste
my time hunting for it.

Ignoring variadic functions like printf, every function call
must pass the appropriate number and types of arguments, matching
the parameters defined by the corresponding function definition.
(In some cases there can be implicit type conversions, but there
are no implicit conversions for arguments or parameters of function
pointer type.) If a correct *prototype* (a function declaration that
specifies the types of all parameters) is visible, this is enforced
at compile time; failing to do so is a *constraint violation*,
requiring a compile-time diagnostic. If no such prototype is
visible, violations of this rule need not be diagnosed, but result
in *undefined behavior*; the C standard says nothing about what
the program will do.

I'll note that the code (declares and) defines the function D,
but never calls it. The address of D is passed to H, but without
a definition of H we can't guess what it does with that address.

It's possible to rewrite the code to (a) avoid the use of old-style
function declarations and (b) avoids any undefined behavior --
but without knowing or being able to guess just what the program
is supposed to do, I see no point in doing so.

The main point is this: The function H is declared but never
defined, so it's impossible to create a running program from this
code, and impossible to guess what it's intended to do without more
information. I will not make any assumptions about how H is meant
to be defined or consult other posts to find a definition. I may or
may not follow this thread to see if any clarifications are posted.

The code as presented is a valid C *translation unit*, but it is
not a valid *program*, and it has no behavior.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+***@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */

Keith Thompson

2024-05-21 02:31:37 UTC

Post by Keith Thompson
[...]

Yes, it does (as you acknowledge in a later post).
typedef int (*ptr)();
defines "ptr" as an alias for a type that can be described in English
as "pointer to function returning int". The empty parentheses
indicate that the function takes an unspecified but fixed number
and type(s) of arguments; this is an old-style declaration.
(The C23 standard, not yet released, changes the semantics of empty
parentheses, causing the code to be invalid, but let's assume C17.)
The function H is declared but not defined. That doesn't prevent
the code from being *compiled*, but it does prevent it from being
*linked* to produce an executable program. Perhaps a definition
of H has been presented in some other article, but I will not waste
my time hunting for it.
Ignoring variadic functions like printf, every function call
must pass the appropriate number and types of arguments, matching
the parameters defined by the corresponding function definition.
(In some cases there can be implicit type conversions, but there
are no implicit conversions for arguments or parameters of function
pointer type.) If a correct *prototype* (a function declaration that
specifies the types of all parameters) is visible, this is enforced
at compile time; failing to do so is a *constraint violation*,
requiring a compile-time diagnostic. If no such prototype is
visible, violations of this rule need not be diagnosed, but result
in *undefined behavior*; the C standard says nothing about what
the program will do.
I'll note that the code (declares and) defines the function D,
but never calls it. The address of D is passed to H, but without
a definition of H we can't guess what it does with that address.
It's possible to rewrite the code to (a) avoid the use of old-style
function declarations and (b) avoids any undefined behavior --
but without knowing or being able to guess just what the program
is supposed to do, I see no point in doing so.
The main point is this: The function H is declared but never
defined, so it's impossible to create a running program from this
code, and impossible to guess what it's intended to do without more
information. I will not make any assumptions about how H is meant
to be defined or consult other posts to find a definition. I may or
may not follow this thread to see if any clarifications are posted.
The code as presented is a valid C *translation unit*, but it is
not a valid *program*, and it has no behavior.

My apologies, I did not notice this had been posted to comp.lang.c++
until just as I posted my followup. If I had noticed that, I probably
wouldn't have posted at all. I'll try to pay better attention.

C++ does not have old-style function declaration. Empty parentheses
in a C++ function declaration or definition indicate that the
function has no parameters. In C++, a pointer of type "ptr" can
only point to a function with no parameters. The call "H(D, D)"
passes the address of the function D (which has one parameter) to
a parameter of type "ptr" (which requires a pointer to a function
with no parameters). That's an error.

The code is ill-formed in C++. And of course the lack of any
definition of H is another problem that makes it difficult or
impossible to correct the C++ errors and produce a valid program.

--
Keith Thompson (The_Other_Keith) Keith.S.Thompson+***@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */

olcott

2024-05-21 03:58:41 UTC

Post by Keith Thompson
[...]

*That was a great review for c17 standards compliance*

I cannot provide the definition for H because I am asking about
the behavior of D simulated by H for the infinite set of H/D pairs.

H is required to correctly simulate 1 to N steps of D and this
may or may not involve H simulating itself simulating D in recursive
simulation.

I have two fully operational versions of H that run under Windows
and Linux. I am not asking about those.

H uses an x86 emulator to emulate the machine code of D and
H is capable of emulating itself emulating D.

typedef int (*ptr)(); // ptr is pointer to int function
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 }

Correct simulation requires correctly emulating the x86 instructions
of D in the order specified by the machine code of D and may include
correctly emulating the x86 instructions of H in the order specified
by the machine code of H.

I need to have experts in these two forums verify that no D correctly
simulated by *pure function* H can possibly reach its own final state
at line 06 and halt in N steps of correct simulation.
https://en.wikipedia.org/wiki/Pure_function#

I thought it was categorically impossible then Richard found a loophole
using static data. This new *pure function* requirement eliminates that
loophole.

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

Fred. Zwarts

2024-05-21 07:39:29 UTC

Post by Keith Thompson
[...]

Post by olcott
typedef int (*ptr)(); // ptr is pointer to int function
int H(ptr x, ptr y);
int D(ptr x)
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
int main()
{
   H(D,D);
   return 0;
}

*That was a great review for c17 standards compliance*
I cannot provide the definition for H because I am asking about
the behavior of D simulated by H for the infinite set of H/D pairs.
H is required to correctly simulate 1 to N steps of D and this
may or may not involve H simulating itself simulating D in recursive
simulation.
I have two fully operational versions of H that run under Windows
and Linux. I am not asking about those.
H uses an x86 emulator to emulate the machine code of D and
H is capable of emulating itself emulating D.
typedef int (*ptr)(); // ptr is pointer to int function
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 }
Correct simulation requires correctly emulating the x86 instructions
of D in the order specified by the machine code of D and may include
correctly emulating the x86 instructions of H in the order specified
by the machine code of H.
I need to have experts in these two forums verify that no D correctly
simulated by *pure function* H can possibly reach its own final state
at line 06 and halt in N steps of correct simulation.
https://en.wikipedia.org/wiki/Pure_function#

Olcott is unable to prove his claim. It seems that he understands,
(although he does not admit) that a claim without a proof has little
value. Therefore is looking for experts to do the home work for him.

Janis Papanagnou

2024-05-21 07:55:21 UTC

Post by olcott
[...]
I cannot provide the definition for H because I am asking about
the behavior of D simulated by H for the infinite set of H/D pairs.
H is required to correctly simulate 1 to N steps of D and this
may or may not involve H simulating itself simulating D in recursive
simulation.
I have two fully operational versions of H that run under Windows
and Linux. I am not asking about those.
H uses an x86 emulator to emulate the machine code of D and
H is capable of emulating itself emulating D.
typedef int (*ptr)(); // ptr is pointer to int function
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 }
Correct simulation requires correctly emulating the x86 instructions
of D in the order specified by the machine code of D and may include
correctly emulating the x86 instructions of H in the order specified
by the machine code of H.
I need to have experts in these two forums verify that no D correctly
simulated by *pure function* H can possibly reach its own final state
at line 06 and halt in N steps of correct simulation.

We're not doing your homework for you. Please provide or elaborate
a rationale or explanation for your claim, thought, or theorem, and
folks here may be able and willing to support you, or show you any
possibly existing deficiencies.

(Fred Zwarts has, with slightly different wording, already given this
hint to you just 24 hours ago. I notice he just repeated that post.)

Just ignoring the replies thus far and stupidly repeating your code
is likely considered pathological behavior and may not be honored by
the audience.

If you don't understand that it's probably better to just hold your
breath until you turn blue instead of repeating your post without
generating any new insights (on both sides).

Post by olcott
https://en.wikipedia.org/wiki/Pure_function#
I thought it was categorically impossible then Richard found a loophole
using static data. This new *pure function* requirement eliminates that
loophole.

olcott

2024-05-21 13:31:36 UTC

Post by Janis Papanagnou

It is not homework.
I claim that D correctly simulated by H (using an x86 emulator)
never reaches its own final state at line 06 and halts for every
H/D pair matching the above template. Additional details are off-topic.

Post by Janis Papanagnou
(Fred Zwarts has, with slightly different wording, already given this
hint to you just 24 hours ago. I notice he just repeated that post.)
Just ignoring the replies thus far and stupidly repeating your code
is likely considered pathological behavior and may not be honored by
the audience.

I do not ignore the replies unless they change the subject.

Post by Janis Papanagnou
If you don't understand that it's probably better to just hold your
breath until you turn blue instead of repeating your post without
generating any new insights (on both sides).

--
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-21 13:56:05 UTC

Post by olcott
It is not homework.
I claim that D correctly simulated by H (using an x86 emulator)
never reaches its own final state at line 06 and halts for every
H/D pair matching the above template. Additional details are off-topic.

What's the practical purpose for that ? I think comp.theory is
a proper group for your questions since your question is generic
to alot of languages.

olcott

2024-05-21 14:09:31 UTC

What's the practical purpose for that ? I think comp.theory is
a proper group for your questions since your question is generic
to alot of languages.

I am only asking the c experts here whether or not D correctly
simulated by *pure function* H can possibly reach its own line
06 and halt for every H/D pair matching the template provided.

On 5/20/2024 9:23 PM, Keith Thompson
confirmed that it is c17 compliant and it does compile

I had to add the *pure function* requirement because Richard found
a loophole using local static data. It had been agreed years ago
that local static data was not allowed yet never expressly stated
in the spec, so Richard took this as a loophole.
https://en.wikipedia.org/wiki/Pure_function#

This aspect <is> a c question. The people on other groups simply
don't know c well enough.

WST 2023: 19th International Workshop on Termination
https://easychair.org/cfp/WST2023

AProVE: Non-Termination Witnesses for C Programs
https://link.springer.com/chapter/10.1007/978-3-030-99527-0_21

--
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-21 18:01:20 UTC

Post by olcott
I am only asking the c experts here whether or not D correctly
simulated by *pure function* H can possibly reach its own line
06 and halt for every H/D pair matching the template provided.

Saying this is a question about C is like questioning something
about physics in Polish and claiming this is a question about
Polish.

olcott

2024-05-21 18:09:08 UTC

Saying this is a question about C is like questioning something
about physics in Polish and claiming this is a question about
Polish.

I am convinced that the question can be fully answered entirely on the
basis of the semantics of C in the exact same way that the termination
status of the following functions can be answered entirely on the basis
of sufficient knowledge of the semantics of c.

*If you believe otherwise then I ask for you to please justify this*

void Infinite_Recursion()
{
Infinite_Recursion();
}

int factorial(int n) // called with 5
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}

void Infinite_Loop()
{
HERE: goto HERE;
}

--
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-21 18:13:47 UTC

Saying this is a question about C is like questioning something
about physics in Polish and claiming this is a question about
Polish.

I am convinced that the question can be fully answered entirely on the
basis of the semantics of C in the exact same way that the termination
status of the following functions can be answered entirely on the basis
of sufficient knowledge of the semantics of c.
*If you believe otherwise then I ask for you to please justify this*
void Infinite_Recursion()
{
Infinite_Recursion();
}
int factorial(int n) // called with 5
{
if (n >= 1)
return n*factorial(n-1);
else
return 1;
}
void Infinite_Loop()
{
HERE: goto HERE;
}

This is possible with most languages so this isn't a question about C.

olcott

2024-05-21 18:24:35 UTC

Saying this is a question about C is like questioning something
about physics in Polish and claiming this is a question about
Polish.

I am convinced that the question can be fully answered entirely on the
basis of the semantics of C in the exact same way that the termination
status of the following functions can be answered entirely on the basis
of sufficient knowledge of the semantics of c.
*If you believe otherwise then I ask for you to please justify this*
void Infinite_Recursion()
{
   Infinite_Recursion();
}
int factorial(int n) // called with 5
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
void Infinite_Loop()
{
   HERE: goto HERE;
}

This is possible with most languages so this isn't a question about C.

None-the-less the semantics of my code template does seem
to prove the result that I stated. I would not even be here
except for the people in the other forum that consistently
lie about this.

--
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-21 18:39:21 UTC

Saying this is a question about C is like questioning something
about physics in Polish and claiming this is a question about
Polish.

I am convinced that the question can be fully answered entirely on the
basis of the semantics of C in the exact same way that the termination
status of the following functions can be answered entirely on the basis
of sufficient knowledge of the semantics of c.
*If you believe otherwise then I ask for you to please justify this*
void Infinite_Recursion()
{
   Infinite_Recursion();
}
int factorial(int n) // called with 5
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
void Infinite_Loop()
{
   HERE: goto HERE;
}

This is possible with most languages so this isn't a question about C.

None-the-less the semantics of my code template does seem
to prove the result that I stated. I would not even be here
except for the people in the other forum that consistently
lie about this.

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

olcott

2024-05-21 18:48:28 UTC

Saying this is a question about C is like questioning something
about physics in Polish and claiming this is a question about
Polish.

I am convinced that the question can be fully answered entirely on the
basis of the semantics of C in the exact same way that the termination
status of the following functions can be answered entirely on the basis
of sufficient knowledge of the semantics of c.
*If you believe otherwise then I ask for you to please justify this*
void Infinite_Recursion()
{
   Infinite_Recursion();
}
int factorial(int n) // called with 5
{
   if (n >= 1)
     return n*factorial(n-1);
   else
     return 1;
}
void Infinite_Loop()
{
   HERE: goto HERE;
}

This is possible with most languages so this isn't a question about C.

None-the-less the semantics of my code template does seem
to prove the result that I stated. I would not even be here
except for the people in the other forum that consistently
lie about this.

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.

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

Sam

2024-05-20 22:59:15 UTC

Post by Bonita Montero
That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.

It's much more preferrable to show actual C code, when asking a C question,
instead of something that looks like BASIC. There are ways of annotating C
code that still manages to accomplish the feat of resulting in valid C code,
that reads naturally to anyone who expects to read C or C++.

Post by olcott
I have been a professional C++ developer since Y2K. So I already
know the answer, I just need some competent people in this forum
to attest to this answer. I met Bjarne Stroustrup back when he
was going around the country promoting his new language.

Big deal. You were hoping to impress someone? I've got about a decade on
you, and I wrote my own K&R C compiler, long before Y2K. I don't brag about
it. Sit down, kid.

Post by olcott
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Of course. A copyright statement. How impressive.

Your delusions of self-grandeur are only your delusions, not shared by
anyone else.

olcott

2024-05-20 23:07:42 UTC

Post by Bonita Montero
That's not research, that's nonsense.

This is not the forum to show that it is not nonsense this is
a simple C question that I should not even have to ask except
for a few people in another forum that consistently lie about
the answer.

It's much more preferrable to show actual C code, when asking a C question,

I can't really do that when I refer to an infinite set of H/D pairs
based on a C programming template.

This is the actual code that does compile.

typedef int (*ptr)();
int H(ptr P, ptr I);

int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
H(D,D);
return 0;
}

H is the infinite set of every H that correctly simulates
N steps of D.

Post by Sam
instead of something that looks like BASIC. There are ways of
annotating C code that still manages to accomplish the feat of resulting
in valid C code, that reads naturally to anyone who expects to read C or
C++.

I had to refer to line numbers to show the exact
execution trace. I can't do that without line numbers.

Big deal. You were hoping to impress someone? I've got about a decade on
you, and I wrote my own K&R C compiler, long before Y2K. I don't brag
about it. Sit down, kid.

People were acting like I was totally clueless. I had a hard
time writing the code to translate control flow instructions
of C until I found out about
https://en.wikipedia.org/wiki/Abstract_syntax_tree
Then it was easy.

Post by olcott
--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Of course. A copyright statement. How impressive.
Your delusions of self-grandeur are only your delusions, not shared by
anyone else.

I am only asking about the behavior of a single
C function template.

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

Sam

2024-05-20 23:21:05 UTC

Post by Sam
Big deal. You were hoping to impress someone? I've got about a decade on
you, and I wrote my own K&R C compiler, long before Y2K. I don't brag about
it. Sit down, kid.

People were acting like I was totally clueless.

Well, there's a name for this phenomenon. It's called "No shit, Sherlock?".

Post by Sam
Of course. A copyright statement. How impressive.
Your delusions of self-grandeur are only your delusions, not shared by
anyone else.

I am only asking about the behavior of a single
C function template.

Well, I don't know how to break the news to you, buddy. You better be
prepared to continue asking, for the foreseeable future. Mastering the art
of copy/paste is highly recommended.

olcott

2024-05-20 23:27:28 UTC

Post by Sam
Big deal. You were hoping to impress someone? I've got about a decade
on you, and I wrote my own K&R C compiler, long before Y2K. I don't
brag about it. Sit down, kid.

People were acting like I was totally clueless.

Well, there's a name for this phenomenon. It's called "No shit, Sherlock?".

People on comp.theory have consistently lied about this
for at least the last two years:

typedef int (*ptr)();
int H(ptr P, ptr I);

int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{
H(D,D);
return 0;
}

This has preventing me from getting to he next step of
my proof that depends on accepting this.

Post by Sam
Of course. A copyright statement. How impressive.
Your delusions of self-grandeur are only your delusions, not shared
by anyone else.

I am only asking about the behavior of a single
C function template.

Well, I don't know how to break the news to you, buddy. You better be
prepared to continue asking, for the foreseeable future. Mastering the
art of copy/paste is highly recommended.

I worked for the Air Force on
https://en.wikipedia.org/wiki/NPOESS

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

Sam

2024-05-21 11:48:36 UTC

Post by olcott
People on comp.theory have consistently lied about this
typedef int (*ptr)();
int H(ptr P, ptr I);
int D(ptr x)
{
int Halt_Status = H(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}
int main()
{
H(D,D);
return 0;
}

Your C compiler also lied to you, if it ever claimed of succeeding in
compiling and producing an executable out of this masterpiece.

Post by olcott
This has preventing me from getting to he next step of
my proof that depends on accepting this.

Aw, so sad. A bunch of random people on the Intertubes is keeping you from
achieving world fame comparable to Einstein's? Sucks to be you.

Post by Sam
Well, I don't know how to break the news to you, buddy. You better be
prepared to continue asking, for the foreseeable future. Mastering the art
of copy/paste is highly recommended.

I worked for the Air Force on
https://en.wikipedia.org/wiki/NPOESS

We've got a real-life Forrest Gump here.

olcott

2024-05-21 13:37:02 UTC

Your C compiler also lied to you, if it ever claimed of succeeding in
compiling and producing an executable out of this masterpiece.

Keith Thompson has confirmed that my code both compiles
and conforms to the c17 standard.

Post by olcott
This has preventing me from getting to he next step of
my proof that depends on accepting this.

Aw, so sad. A bunch of random people on the Intertubes is keeping you
from achieving world fame comparable to Einstein's? Sucks to be you.

Post by Sam
Well, I don't know how to break the news to you, buddy. You better be
prepared to continue asking, for the foreseeable future. Mastering
the art of copy/paste is highly recommended.

I worked for the Air Force on
https://en.wikipedia.org/wiki/NPOESS

We've got a real-life Forrest Gump here.

--
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-21 19:03:21 UTC

Your C compiler also lied to you, if it ever claimed of succeeding in
compiling and producing an executable out of this masterpiece.

Keith Thompson has confirmed that my code both compiles
and conforms to the c17 standard.

Where did he say exactly that?

[...]

olcott

2024-05-21 19:21:24 UTC

Your C compiler also lied to you, if it ever claimed of succeeding in
compiling and producing an executable out of this masterpiece.

Keith Thompson has confirmed that my code both compiles
and conforms to the c17 standard.

Where did he say exactly that?
[...]

He only commented on the one-line-of code that does vary between
c17 and c23. The rest of the code has been standard for a long time.
I have been programming in C back when K & R was the standard.

On 5/20/2024 9:23 PM, Keith Thompson wrote:
Message-ID: <***@nosuchdomain.example.com>
http://al.howardknight.net/?STYPE=msgid&MSGI=%3C87v837kinv.fsf%40nosuchdomain.example.com%3E

H completely ignores that I have stated that this is a function template
specifying an infinite set of H/D pairs such that (pure function) H is
only required to simulate N steps of D with an x86 emulator.

--
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-21 21:39:23 UTC

Your C compiler also lied to you, if it ever claimed of succeeding
in compiling and producing an executable out of this masterpiece.

Keith Thompson has confirmed that my code both compiles
and conforms to the c17 standard.

Where did he say exactly that?
[...]

He only commented on the one-line-of code that does vary between
c17 and c23. The rest of the code has been standard for a long time.
I have been programming in C back when K & R was the standard.

Show me a working C program. Where we all can compile and run the damn
thing...

Sam

2024-05-21 21:55:42 UTC

Your C compiler also lied to you, if it ever claimed of succeeding in
compiling and producing an executable out of this masterpiece.

Keith Thompson has confirmed that my code both compiles
and conforms to the c17 standard.

Where did he say exactly that?
[...]

That link states that Keith Thompson plainly told you that the code will not
link. As such, it cannot be executed, since linking (in order to produce a
working executable) is a necessary prerequisite for that.

As such, all further claims about what the shown code does or does not do,
are immaterial, because the shown code will never work.

"Compiled", in common use, frequently encompasses both the compilation and
the linking stage, and is commonly used to refer to both processes, together.

olcott

2024-05-21 22:09:01 UTC

Your C compiler also lied to you, if it ever claimed of succeeding
in compiling and producing an executable out of this masterpiece.

Keith Thompson has confirmed that my code both compiles
and conforms to the c17 standard.

Where did he say exactly that?
[...]

*This one has line numbers*

typedef int (*ptr)(); // ptr is pointer to int function
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 }

*I changed the subject line*
*I changed the subject line*
*I changed the subject line*

I learned C when K & R was the standard.
I met Bjarne Stroustrup are our local university when he
was promoting his new language. I have been a professional
programmer since 1984, and a professional C++ software
engineer since Y2K.

I know that my C function template will not execute.

I can't provide the details of this because this template refers to
an infinite set of H/D pairs where H is only required to correctly
simulate N steps of D using an x86 emulator. H must be a pure function.

I have two fully operational versions of H that run under Windows
and Linux. Those are off topic.

Post by Sam
As such, all further claims about what the shown code does or does not
do, are immaterial, because the shown code will never work.
"Compiled", in common use, frequently encompasses both the compilation
and the linking stage, and is commonly used to refer to both processes,
together.

--
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-21 04:00:42 UTC

Post by Sam
Big deal. You were hoping to impress someone? I've got about a decade
on you, and I wrote my own K&R C compiler, long before Y2K. I don't
brag about it. Sit down, kid.

People were acting like I was totally clueless.

Well, there's a name for this phenomenon. It's called "No shit, Sherlock?".

Post by Sam
Of course. A copyright statement. How impressive.
Your delusions of self-grandeur are only your delusions, not shared
by anyone else.

I am only asking about the behavior of a single
C function template.

Well, I don't know how to break the news to you, buddy. You better be
prepared to continue asking, for the foreseeable future. Mastering the
art of copy/paste is highly recommended.

I am still not sure what olcott is asking. Will this halt? Not if the
system has infinite time and energy...
______________________
#include <stdio.h>

void foobar(unsigned int volatile* a)
{
for (;;)
{
++(*a);
}
}

int main() {
unsigned int a = 0;

foobar(&a);

printf("a = %u", a);

return 0;
}
______________________

What is his point?

olcott

2024-05-21 04:22:17 UTC

Post by Chris M. Thomasson
What is his point?

Keith Thompson verified it does compile and is c17
standard compliant.

*I renamed this thread to focus on the key point*
*I renamed this thread to focus on the key point*
*I renamed this thread to focus on the key point*

typedef int (*ptr)(); // ptr is pointer to int function
00 int H(ptr x, ptr y);
01 int D(ptr x)
02 {
03 int Halt_Status = H(x, x);
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 }

The above template specifies and infinite set of H/D pairs where
*pure function* H correctly simulates N steps of D with an x86 emulator.
https://en.wikipedia.org/wiki/Pure_function#

*Execution Trace*
Line 11: main() invokes H(D,D);

*keeps repeating* (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

I need to verify that D correctly simulated by any *pure function*
H cannot possibly reach its own line 06 and halt.

Richard just found a loophole using static local data, so I added
the *pure function* requirement.

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

Marcel Mueller

2024-05-20 13:14:43 UTC

Post by olcott
In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.
This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

There is no recursion.
H is an undefined reference. There is nothing to simulate.

And even if H would be defined, the implementation of H might never call
*x or *y.

Post by olcott
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

So this is proven not to be true in general.

Marcel

olcott

2024-05-20 15:10:11 UTC

Post by Marcel Mueller

There is no recursion.
H is an undefined reference. There is nothing to simulate.
And even if H would be defined, the implementation of H might never call
*x or *y.

Post by olcott
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
*Simulation invariant*
D correctly simulated by H cannot possibly reach past its own line 03.

So this is proven not to be true in general.
Marcel

https://en.wikipedia.org/wiki/Pure_function#

*Try to find any way that*
For every H/D pair of the template below where D correctly simulated
by pure function (thus computable function) H can possibly reach its
own final state at line 06 and halt.

typedef int (*ptr)(); // ptr is pointer to int function
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 }

In the above case a simulator is an x86 emulator that correctly emulates
at least one of the x86 instructions of D in the order specified by the
x86 instructions of D.

This may include correctly emulating the x86 instructions of H in the
order specified by the x86 instructions of H thus calling H(D,D) in
recursive simulation.

Execution Trace
Line 11: main() invokes H(D,D);

keeps repeating (unless aborted)
Line 01:
Line 02:
Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

Simulation invariant:
D correctly simulated by H cannot possibly reach past its own line 03.

For every H/D pair of the above template D correctly simulated by pure
function (thus computable function) H cannot possibly reach its own
final state at line 06 and halt.

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

olcott

2024-05-20 15:13:32 UTC