From Newsgroup: comp.lang.c

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
HHH(DDD);
return;
}

int main()
{
HHH(DDD);
DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*

*That last sentence is an intentional falsehood*
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
  HHH(DDD);
  return;
}

int main()
{
  HHH(DDD);
  DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right? Like I've pointed out to
you on several occasions. Maybe you should consider a simple misunderstanding over terminology
before assuming bad intentions.

So what does Alan mean by "the simulation by HHH is incorrect", exactly? (And why do you think it
is incorrect?)

That is a question for PO, rather than Alan, since it is PO who claims Alan is lying...

Mike.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:
;

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

;
Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*
;

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right?

*There is only one correct way*

void DDD()
{
HHH(DDD);
return;
}

The correct simulation of DDD by HHH means that HHH simulates
DDD and then emulates itself simulating DDD a number of times
according to the semantics of C.

Everyone here knows that DDD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement.
Most everyone on comp.theory lies about this.

Like I've pointed out to you on several occasions.  Maybe you should consider a simple misunderstanding over terminology before assuming bad intentions.

After three years on this same point a simple misunderstanding
has been ruled out.

So what does Alan mean by "the simulation by HHH is incorrect",
exactly?  (And why do you think it is incorrect?)

He is simply lying. Most of the reviews of my work are
counter-factual dogmatic assertions utterly bereft of
any supporting reasoning.

That is a question for PO, rather than Alan, since it is PO who claims
Alan is lying...

Mike.

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

From Newsgroup: comp.lang.c

On 28/06/2025 16:00, olcott wrote:

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right?

*There is only one correct way*

That's patently rubbish.

This is one of your major cognitive mistakes - believing that the squiggles which make up words have
an absolute meaning independently of the people using them to (hopefully) communicate.

void DDD()
{
  HHH(DDD);
  return;
}

The correct simulation of DDD by HHH means that HHH simulates
DDD and then emulates itself simulating DDD a number of times
according to the semantics of C.

"a number of times"???

a) Does a correct simulation need to simulate until its target computation terminates?

b) Does a simulation need to also correctly decide halting for its target computation?

[My personal answers would be "no" and "no" - I would consider what others may insist on calling a
partial simulation to a correct example of "simulation" (but of course incomplete), provided the
steps of the simulation are correctly calculated; and I consider deciding the halt status to be the
job of a halt "decider" rather than a simulator [of course a halt decider may /utilise/ simulation
as a technique in reaching its decision]. Other ways of looking at this are equally valid and we
need to understand each other's positions.]

Everyone here knows that DDD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement.

That's what Alan said above. Read his words: "Everybody else knows this, too, and nobody has said
otherwise." You need to read what people write and keep track of the conversation...

Most everyone on comp.theory lies about this.

Well, not Alan (whom you accused), or me, or Richard or Mikko or Fred (I expect I could include
others but can't be bothered to research the question).

So who lies about it exactly, and you had better provide a (recent) link to them lying! Or just
admit you haven't a clue what people are actually saying to you...

Like I've pointed out to you on several occasions.  Maybe you should consider a simple
misunderstanding over terminology before assuming bad intentions.

After three years on this same point a simple misunderstanding
has been ruled out.

For a "normal" correspondant perhaps, but you forget your own disabilities - you are incapable of
understanding what people say to you, including whether they are agreeing with you (in strictly
limited parts) or not.

So what does Alan mean by "the simulation by HHH is incorrect", exactly?  (And why do you think it
is incorrect?)

He is simply lying. Most of the reviews of my work are
counter-factual dogmatic assertions utterly bereft of
any supporting reasoning.

Lol, you haven't even answered the question of what you think Alan meant by his statement, or why
that is a lie. So how can you be sure he is lying? All you've talked about above is the bit Alan
explicitly said he /agreed/ with.


Mike.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 6/28/2025 11:22 AM, Mike Terry wrote:

On 28/06/2025 16:00, olcott wrote:

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:
;

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

;
Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*
;

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right?

*There is only one correct way*

That's patently rubbish.

This is one of your major cognitive mistakes - believing that the
squiggles which make up words have an absolute meaning independently of
the people using them to (hopefully) communicate.

void DDD()
{
   HHH(DDD);
   return;
}

The correct simulation of DDD by HHH means that HHH simulates
DDD and then emulates itself simulating DDD a number of times
according to the semantics of C.

"a number of times"???

Do you know what a number is?
In this case I am referring to every non-negative integer.

a)   Does a correct simulation need to simulate until its target computation terminates?

There is no target computation here we only have the
behavior that the input to HHH(DDD) specifies.

Anyone that knows what recursion is should be able to
see that DDD correctly simulated by HHH never reaches
its own simulated "return" instruction final halt state.

b)   Does a simulation need to also correctly decide halting for its target computation?

There is no target computation here we only have the
behavior that the input to HHH(DDD) specifies.

[My personal answers would be "no" and "no" - I would consider what
others may insist on calling a partial simulation to a correct example
of "simulation" (but of course incomplete), provided the steps of the simulation are correctly calculated; and I consider deciding the halt
status to be the job of a halt "decider" rather than a simulator [of
course a halt decider may /utilise/ simulation as a technique in
reaching its decision].  Other ways of looking at this are equally valid and we need to understand each other's positions.]

Everyone here knows that DDD correctly simulated by HHH
cannot possibly reach its own simulated "return" statement.

That's what Alan said above.  Read his words:  "Everybody else knows
this, too,

Alan dishonesty changed the words of my quote erasing
the word "correctly".

and nobody has said otherwise."  You need to read what people
write and keep track of the conversation...

I didn't notice that Alan dishonestly changed the words
of my quote at first either. That is why I check these
things many times before I submit my reply.

Most everyone on comp.theory lies about this.

Well, not Alan (whom you accused), or me,  or Richard or Mikko or Fred
(I expect I could include others but can't be bothered to research the question).

So who lies about it exactly, and you had better provide a (recent) link
to them lying!  Or just admit you haven't a clue what people are
actually saying to you...

*Everyone besides Keith has denied this verified fact*
DDD correctly simulated by HHH cannot possibly reach
its own simulated "return" statement final halt state.

Like I've pointed out to you on several occasions.  Maybe you should
consider a simple misunderstanding over terminology before assuming
bad intentions.

After three years on this same point a simple misunderstanding
has been ruled out.

For a "normal" correspondant perhaps, but you forget your own
disabilities - you are incapable of understanding what people say to
you, including whether they are agreeing with you (in strictly limited parts) or not.

That is counter-factual.
When I reject their counter-factual statements
this is not any lack of understanding on my part.

So what does Alan mean by "the simulation by HHH is incorrect",
exactly?  (And why do you think it is incorrect?)

He is simply lying. Most of the reviews of my work are
counter-factual dogmatic assertions utterly bereft of
any supporting reasoning.

Lol, you haven't even answered the question of what you think Alan meant
by his statement,

It does not matter how he made a counter-factual statement
it only matters that it was counter-factual.

That he seems to think that he can get away with disagreeing
with the semantics of the C programming language doesn't seem
like it could reasonably be construed as any honest mistake.

or why that is a lie.  So how can you be sure he is
lying?  All you've talked about above is the bit Alan explicitly said
he /agreed/ with.

You did not notice that he dishonestly changed the words
of my quote and the agreed with these changed words. This
is a deceptive tactic known as the strawman error.

Mike.

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

From Newsgroup: comp.lang.c

On 28/06/2025 17:47, olcott wrote:

On 6/28/2025 11:22 AM, Mike Terry wrote:

On 28/06/2025 16:00, olcott wrote:

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right? >>>

*There is only one correct way*

That's patently rubbish.

This is one of your major cognitive mistakes - believing that the squiggles which make up words
have an absolute meaning independently of the people using them to (hopefully) communicate.

void DDD()
{
   HHH(DDD);
   return;
}

The correct simulation of DDD by HHH means that HHH simulates
DDD and then emulates itself simulating DDD a number of times
according to the semantics of C.

"a number of times"???

Do you know what a number is?
In this case I am referring to every non-negative integer.

a)   Does a correct simulation need to simulate until its target computation terminates?

There is no target computation here we only have the
behavior that the input to HHH(DDD) specifies.

ok I see you intend to be completely non-responsive, just as you were in the "diverging simulations"
thread.

I'll just point out for the record that you haven't provided any justification for accusing Alan or
anybody else of lying to you. Indeed, your responses just show that you have no clue what other
people are saying to you!

Mike.

--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 6/28/2025 12:38 PM, Mike Terry wrote:

On 28/06/2025 17:47, olcott wrote:

On 6/28/2025 11:22 AM, Mike Terry wrote:

On 28/06/2025 16:00, olcott wrote:

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:
;

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

;
Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*
;

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways,
right?

*There is only one correct way*

That's patently rubbish.

This is one of your major cognitive mistakes - believing that the
squiggles which make up words have an absolute meaning independently
of the people using them to (hopefully) communicate.

void DDD()
{
   HHH(DDD);
   return;
}

The correct simulation of DDD by HHH means that HHH simulates
DDD and then emulates itself simulating DDD a number of times
according to the semantics of C.

"a number of times"???

Do you know what a number is?
In this case I am referring to every non-negative integer.

a)   Does a correct simulation need to simulate until its target
computation terminates?

There is no target computation here we only have the
behavior that the input to HHH(DDD) specifies.

ok I see you intend to be completely non-responsive, just as you were in
the "diverging simulations" thread.

I'll just point out for the record that you haven't provided any justification for accusing Alan or anybody else of lying to you.
Indeed, your responses just show that you have no clue what other people
are saying to you!

Mike.

*I wasn't clear enough*
Here proof that Alan was dishonest by changing my
quoted words and changing the time date stamp to
make it more difficult to see that he was cheating.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com> wrote:

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

Everybody else knows this, too, and nobody has said otherwise.
The conclusion is that the simulation by HHH is incorrect.

On 6/27/2025 11:34 AM, olcott wrote:

I know that DDD correctly simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

Since HHH simulates DDD according to the semantics of the C
programming language this simulation is necessarily correct.

Disagreeing with this tries to get away with disagreeing
with the semantics of the C programming language.
How can that be honest?

It is also the case that everyone besides Keith
on comp.theory has disagreed with these words:

DDD correctly simulated by HHH cannot possibly reach
its own simulated "return" statement final halt state.
--
Copyright 2025 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.c

On 6/28/2025 12:38 PM, Mike Terry wrote:

On 28/06/2025 17:47, olcott wrote:

On 6/28/2025 11:22 AM, Mike Terry wrote:

On 28/06/2025 16:00, olcott wrote:

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:
;

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

;
Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*
;

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways,
right?

*There is only one correct way*

That's patently rubbish.

This is one of your major cognitive mistakes - believing that the
squiggles which make up words have an absolute meaning independently
of the people using them to (hopefully) communicate.

void DDD()
{
   HHH(DDD);
   return;
}

The correct simulation of DDD by HHH means that HHH simulates
DDD and then emulates itself simulating DDD a number of times
according to the semantics of C.

"a number of times"???

Do you know what a number is?
In this case I am referring to every non-negative integer.

a)   Does a correct simulation need to simulate until its target
computation terminates?

There is no target computation here we only have the
behavior that the input to HHH(DDD) specifies.

ok I see you intend to be completely non-responsive,

In a c/c++ group when talking about the behavior of an
input to a simulating termination analyzer we only
examine what DDD simulated by HHH (according to the
semantics of the C programming language) actually does.

There is no theory of computation "target" computation
in this case.

just as you were in
the "diverging simulations" thread.

I'll just point out for the record that you haven't provided any justification for accusing Alan or anybody else of lying to you.
Indeed, your responses just show that you have no clue what other people
are saying to you!

Mike.

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

From Newsgroup: comp.lang.c

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:
;

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

;
Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*
;

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right? Like I've pointed out to you on several occasions.  Maybe you should consider a simple misunderstanding over terminology before assuming bad intentions.

So what does Alan mean by "the simulation by HHH is incorrect",
exactly?  (And why do you think it is incorrect?)

*He can't possibly mean anything truthful*
*He can't possibly mean anything truthful*
*He can't possibly mean anything truthful*

void DDD()
{
HHH(DDD);
return;
}

At the C level HHH simulates DDD that calls HHH(DDD)
that DDD simulates DDD that calls HHH(DDD)
that DDD simulates DDD that calls HHH(DDD)
that DDD simulates DDD that calls HHH(DDD)
that DDD simulates DDD that calls HHH(DDD)

until HHH correctly determines that DDD simulated by HHH
(according to the semantics of the C programming language)
cannot possibly reach its own simulated "return" instruction
(final halt state).

*Here is the same thing at the x86 machine code level*
(what HHH actually sees and analyzes)

_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192 // push DDD
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]

The x86 source code of DDD specifies that this emulated
DDD cannot possibly reach its own emulated "ret" instruction
final halt state when emulated by HHH according to the
semantics of the x86 language.

That is a question for PO, rather than Alan, since it is PO who claims
Alan is lying...

Mike.

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

From Newsgroup: comp.lang.c

On 6/27/2025 7:14 PM, Mike Terry wrote:

On 27/06/2025 20:36, olcott wrote:

I am only here for the validation of the behavior
of DDD correctly simulated by HHH.

I have included proof that the people on comp.theory
lied about this at the bottom.

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

void DDD()
{
   HHH(DDD);
   return;
}

int main()
{
   HHH(DDD);
   DDD();
}

Termination Analyzer HHH simulates its input until
it detects a non-terminating behavior pattern. When
HHH detects such a pattern it aborts its simulation
and returns 0.

On 6/27/2025 12:27 PM, Alan Mackenzie wrote:

In comp.theory olcott <polcott333@gmail.com
wrote:
;

I know that DDD .... simulated by HHH cannot
possibly reach its own simulated "return" statement
final halt state because the execution trace
conclusively proves this.

;
Everybody else knows this, too, and nobody has
said otherwise. *The conclusion is that the*
*simulation by HHH is incorrect*
;

*That last sentence is an intentional falsehood*

Well, people here use the term "simulation" in a number of ways, right? Like I've pointed out to you on several occasions.  Maybe you should consider a simple misunderstanding over terminology before assuming bad intentions.

So what does Alan mean by "the simulation by HHH is incorrect",
exactly?  (And why do you think it is incorrect?)

*He can't possibly mean anything truthful*
*He can't possibly mean anything truthful*
*He can't possibly mean anything truthful*

void DDD()
{
HHH(DDD);
return;
}

At the C level
HHH simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)
that simulates DDD that calls HHH(DDD)

until HHH correctly determines that DDD simulated by HHH
(according to the semantics of the C programming language)
cannot possibly reach its own simulated "return" instruction
(final halt state).

*Here is the same thing at the x86 machine code level*
(what HHH actually sees and analyzes)

_DDD()
[00002192] 55 push ebp
[00002193] 8bec mov ebp,esp
[00002195] 6892210000 push 00002192 // push DDD
[0000219a] e833f4ffff call 000015d2 // call HHH
[0000219f] 83c404 add esp,+04
[000021a2] 5d pop ebp
[000021a3] c3 ret
Size in bytes:(0018) [000021a3]

The x86 source code of DDD specifies that this emulated
DDD cannot possibly reach its own emulated "ret" instruction
final halt state when emulated by HHH according to the
semantics of the x86 language.

That is a question for PO, rather than Alan, since it is PO who claims
Alan is lying...

Mike.

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