Re: Can someone please verify the execution trace of this?

Op 20.mei.2024 om 07:38 schreef olcott:

On 5/20/2024 12:09 AM, Bonita Montero wrote:

Am 20.05.2024 um 04:43 schrieb olcott:

On 5/19/2024 8:52 PM, Bonita Montero wrote:

Am 19.05.2024 um 21:00 schrieb olcott:

On 5/19/2024 1:08 PM, Bonita Montero wrote:

Am 18.05.2024 um 23:40 schrieb 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 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.
>
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.
>

>
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.

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.