Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c++ > #122366 > unrolled thread

DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory

Back to article view | Back to comp.lang.c++

Contents

  DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-27 14:36 -0500
    Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-06-28 01:14 +0100
      Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 10:00 -0500
        Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-06-28 17:22 +0100
          Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 11:47 -0500
            Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-06-28 18:38 +0100
              Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 13:08 -0500
              Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 14:16 -0500
      Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-29 10:41 -0500
      Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- (Typo corrected) olcott <polcott333@gmail.com> - 2025-06-29 10:48 -0500
    Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory wij <wyniijj5@gmail.com> - 2025-06-28 15:43 +0800
      Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 10:04 -0500
        Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory dbush <dbush.mobile@gmail.com> - 2025-06-28 11:14 -0400
          Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 10:17 -0500
            Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory dbush <dbush.mobile@gmail.com> - 2025-06-28 11:21 -0400
              Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 10:30 -0500
                Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory dbush <dbush.mobile@gmail.com> - 2025-06-28 11:39 -0400
                  Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 10:46 -0500
                    Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory dbush <dbush.mobile@gmail.com> - 2025-06-28 11:52 -0400
                      Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 11:03 -0500
                        Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory dbush <dbush.mobile@gmail.com> - 2025-06-28 13:13 -0400
                          Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 12:27 -0500
                            Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory dbush <dbush.mobile@gmail.com> - 2025-06-28 13:43 -0400
                              Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 13:16 -0500
                          Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory olcott <polcott333@gmail.com> - 2025-06-28 12:35 -0500

Page 1 of 2  [1] 2  Next page →

#122366 — DDD correctly simulated by HHH can't possibly reach its own "return" statement --- Liars on comp.theory

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

[toc] | [next] | [standalone]

#122370

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.

[toc] | [prev] | [next] | [standalone]

#122374

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

[toc] | [prev] | [next] | [standalone]

#122386

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.

[toc] | [prev] | [next] | [standalone]

#122387

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

[toc] | [prev] | [next] | [standalone]

#122393

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.

[toc] | [prev] | [next] | [standalone]

#122395

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

[toc] | [prev] | [next] | [standalone]

#122398

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

[toc] | [prev] | [next] | [standalone]

#122407

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

[toc] | [prev] | [next] | [standalone]

#122408 — Re: DDD correctly simulated by HHH can't possibly reach its own "return" statement --- (Typo corrected)

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

[toc] | [prev] | [next] | [standalone]

#122373

On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
> I am only here for the validation of the behavior
> of DDD correctly simulated by HHH.

The definition of HHH is missing.
(Don't bother answering this question. We know what you would say.)

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

HHH(DDD) will run in infinite loop, which conforms to Halting Problem proof.

> When
> HHH detects such a pattern it aborts its simulation
> and returns 0.

This looks like a problem specification, but you said "Halting Problem" is
incorrect. Peter Olcott's Own Problem is never clear.

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

Actually, it is olcott who lies. The evidence keeps accumulating for years.
Because the evidences (olcott's posts) show that olcott knows what the HP says,
he deliberately and very stubbornly wants to conclude differently by trying 
every possible way (for years, and think he will hit the target).

Because olcott is so Computer-Science-Stupid (He doesn't understand the 
meaning of logic-IF. He can't write a TM that computes the length of its 
input. The proof of a piece of C program is its compiled assembly,...) 
to lie?

I prefer to say olcott deliberately lies, because he does experiment with a
real program (where he tried various ways to make it interpret-able as what he
claims) he knows what happens and makes false reports (not what has actually
happened, like this post, he knows what is inappropriate and not good to his
claim) to 'prove' his claim even thought there is no logical connection 
(always like to saying "a white dog", while pointing to a black cat). 
It is still so, hardly to see olcott posts real thing instead of confusing
equivocal arguments.

[toc] | [prev] | [next] | [standalone]

#122375

On 6/28/2025 2:43 AM, wij wrote:
> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>> I am only here for the validation of the behavior
>> of DDD correctly simulated by HHH.
> 
> The definition of HHH is missing.

The definition is specified in this part that you
dishonestly erased:

On 6/27/2025 2:36 PM, olcott wrote:
 > 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.





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

[toc] | [prev] | [next] | [standalone]

#122377

On 6/28/2025 11:04 AM, olcott wrote:
> On 6/28/2025 2:43 AM, wij wrote:
>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>> I am only here for the validation of the behavior
>>> of DDD correctly simulated by HHH.
>>
>> The definition of HHH is missing.
> 
> The definition is specified in this part that you
> dishonestly erased:
> 
> On 6/27/2025 2:36 PM, olcott wrote:
>  > 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.
> 

The dishonest one here is YOU, as it was not wij who snipped the below 
in his reply but YOU:

>>> 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.
>> 
>> HHH(DDD) will run in infinite loop, which conforms to Halting Problem proof.
>> 
>>> When
>>> HHH detects such a pattern it aborts its simulation
>>> and returns 0.

And here is the part that you dishonestly said was erased when in fact 
it was not.

This proves that it is YOU who are lying and will say anything to push 
your agenda.

>> 
>> This looks like a problem specification, but you said "Halting Problem" is
>> incorrect. Peter Olcott's Own Problem is never clear. 

[toc] | [prev] | [next] | [standalone]

#122378

On 6/28/2025 10:14 AM, dbush wrote:
> On 6/28/2025 11:04 AM, olcott wrote:
>> On 6/28/2025 2:43 AM, wij wrote:
>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>> I am only here for the validation of the behavior
>>>> of DDD correctly simulated by HHH.
>>>
>>> The definition of HHH is missing.
>>
>> The definition is specified in this part that you
>> dishonestly erased:
>>
>> On 6/27/2025 2:36 PM, olcott wrote:
>>  > 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.
>>
> 
> The dishonest one here is YOU, as it was not wij who snipped the below 
> in his reply but YOU:
> 

I stop at the first counter-factual mistake so I stop here.
Everything else is ignored.

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

[toc] | [prev] | [next] | [standalone]

#122379

On 6/28/2025 11:17 AM, olcott wrote:
> On 6/28/2025 10:14 AM, dbush wrote:
>> On 6/28/2025 11:04 AM, olcott wrote:
>>> On 6/28/2025 2:43 AM, wij wrote:
>>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>>> I am only here for the validation of the behavior
>>>>> of DDD correctly simulated by HHH.
>>>>
>>>> The definition of HHH is missing.
>>>
>>> The definition is specified in this part that you
>>> dishonestly erased:
>>>
>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>  > 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.
>>>
>>
>> The dishonest one here is YOU, as it was not wij who snipped the below 
>> in his reply but YOU:
>>
> 
> I stop at the first counter-factual mistake so I stop here.
> Everything else is ignored.
>

In other words, you INTENTIONALLY don't read things that prove you wrong.

Your dishonesty knows no bounds.  And as you yourself self:

On 5/25/2025 3:04 PM, olcott wrote:
 > You Are the epitome of bad faith and dishonesty.
 > This may cost you your actual soul: Revelations 21:8.


>>>>> 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.
>>>>
>>>> HHH(DDD) will run in infinite loop, which conforms to Halting Problem 
>>>> proof.
>>>>
>>>>> When
>>>>> HHH detects such a pattern it aborts its simulation
>>>>> and returns 0.
>> 
>> And here is the part that you dishonestly said was erased when in fact 
>> it was not.
>> 
>> This proves that it is YOU who are lying and will say anything to push 
>> your agenda.
>> 

Your failure to reply to the above, and in fact your dishonest erasing 
of it constitutes your admission of lying to push your agenda.

>>>>
>>>> This looks like a problem specification, but you said "Halting 
>>>> Problem" is
>>>> incorrect. Peter Olcott's Own Problem is never clear. 

[toc] | [prev] | [next] | [standalone]

#122380

On 6/28/2025 10:21 AM, dbush wrote:
> On 6/28/2025 11:17 AM, olcott wrote:
>> On 6/28/2025 10:14 AM, dbush wrote:
>>> On 6/28/2025 11:04 AM, olcott wrote:
>>>> On 6/28/2025 2:43 AM, wij wrote:
>>>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>>>> I am only here for the validation of the behavior
>>>>>> of DDD correctly simulated by HHH.
>>>>>
>>>>> The definition of HHH is missing.
>>>>
>>>> The definition is specified in this part that you
>>>> dishonestly erased:
>>>>
>>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>>  > 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.
>>>>
>>>
>>> The dishonest one here is YOU, as it was not wij who snipped the 
>>> below in his reply but YOU:
>>>
>>
>> I stop at the first counter-factual mistake so I stop here.
>> Everything else is ignored.
>>
> 
> In other words, you INTENTIONALLY don't read things that prove you wrong.
> 

On 6/28/2025 2:43 AM, wij wrote:
 >
 > The definition of HHH is missing.

On 6/27/2025 2:36 PM, olcott wrote:
 > 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.
 >

It is a verified fact that the definition of HHH was
provided thus the claim that it was not provided is
counter factual.

Your mere rhetoric to the contrary does not actually change
these verified facts. Are you able to stick with correct
reasoning or is mere rhetoric all that you have?

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

[toc] | [prev] | [next] | [standalone]

#122382

On 6/28/2025 11:30 AM, olcott wrote:
> On 6/28/2025 10:21 AM, dbush wrote:
>> On 6/28/2025 11:17 AM, olcott wrote:
>>> On 6/28/2025 10:14 AM, dbush wrote:
>>>> On 6/28/2025 11:04 AM, olcott wrote:
>>>>> On 6/28/2025 2:43 AM, wij wrote:
>>>>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>>>>> I am only here for the validation of the behavior
>>>>>>> of DDD correctly simulated by HHH.
>>>>>>
>>>>>> The definition of HHH is missing.
>>>>>
>>>>> The definition is specified in this part that you
>>>>> dishonestly erased:
>>>>>
>>>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>>>  > 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.
>>>>>
>>>>
>>>> The dishonest one here is YOU, as it was not wij who snipped the 
>>>> below in his reply but YOU:
>>>>
>>>
>>> I stop at the first counter-factual mistake so I stop here.
>>> Everything else is ignored.
>>>
>>
>> In other words, you INTENTIONALLY don't read things that prove you wrong.
>>
> 
> On 6/28/2025 2:43 AM, wij wrote:
>  >
>  > The definition of HHH is missing.
> 
> On 6/27/2025 2:36 PM, olcott wrote:
>  > 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.
>  >
> 
> It is a verified fact that the definition of HHH was
> provided thus the claim that it was not provided is
> counter factual.


No, you didn't give a definition of HHH, just gave a vauge incomplete 
description of what you think it does.

What is is a verified fact that you openly and blatantly lied about wij 
erasing your description when it was in fact you yourself that did it.

All you are doing is showing the depths of your dishonesty.


> 
> Your mere rhetoric to the contrary does not actually change
> these verified facts. Are you able to stick with correct
> reasoning or is mere rhetoric all that you have?
>
>> Your dishonesty knows no bounds.  And as you yourself self:
>> 
>> On 5/25/2025 3:04 PM, olcott wrote:
>>  > You Are the epitome of bad faith and dishonesty.
>>  > This may cost you your actual soul: Revelations 21:8.
>> 
>> 
>>>>>>> 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.
>>>>>>
>>>>>> HHH(DDD) will run in infinite loop, which conforms to Halting 
>>>>>> Problem proof.
>>>>>>
>>>>>>> When
>>>>>>> HHH detects such a pattern it aborts its simulation
>>>>>>> and returns 0.
>>>>
>>>> And here is the part that you dishonestly said was erased when in 
>>>> fact it was not.
>>>>
>>>> This proves that it is YOU who are lying and will say anything to 
>>>> push your agenda.
>>>>
>> 
>> Your failure to reply to the above, and in fact your dishonest erasing 
>> of it constitutes your admission of lying to push your agenda.
>> 
>>>>>>
>>>>>> This looks like a problem specification, but you said "Halting 
>>>>>> Problem" is
>>>>>> incorrect. Peter Olcott's Own Problem is never clear.  

[toc] | [prev] | [next] | [standalone]

#122383

On 6/28/2025 10:39 AM, dbush wrote:
> On 6/28/2025 11:30 AM, olcott wrote:
>> On 6/28/2025 10:21 AM, dbush wrote:
>>> On 6/28/2025 11:17 AM, olcott wrote:
>>>> On 6/28/2025 10:14 AM, dbush wrote:
>>>>> On 6/28/2025 11:04 AM, olcott wrote:
>>>>>> On 6/28/2025 2:43 AM, wij wrote:
>>>>>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>>>>>> I am only here for the validation of the behavior
>>>>>>>> of DDD correctly simulated by HHH.
>>>>>>>
>>>>>>> The definition of HHH is missing.
>>>>>>
>>>>>> The definition is specified in this part that you
>>>>>> dishonestly erased:
>>>>>>
>>>>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>>>>  > 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.
>>>>>>
>>>>>
>>>>> The dishonest one here is YOU, as it was not wij who snipped the 
>>>>> below in his reply but YOU:
>>>>>
>>>>
>>>> I stop at the first counter-factual mistake so I stop here.
>>>> Everything else is ignored.
>>>>
>>>
>>> In other words, you INTENTIONALLY don't read things that prove you 
>>> wrong.
>>>
>>
>> On 6/28/2025 2:43 AM, wij wrote:
>>  >
>>  > The definition of HHH is missing.
>>
>> On 6/27/2025 2:36 PM, olcott wrote:
>>  > 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.
>>  >
>>
>> It is a verified fact that the definition of HHH was
>> provided thus the claim that it was not provided is
>> counter factual.
> 
> 
> No, you didn't give a definition of HHH, just gave a vauge incomplete 
> description of what you think it does.
> 

It completely defines the generic notion of a simulating
termination analyzer and

It specifies every detail about HHH that is required
to correctly determine whether or not DDD correctly
simulated by HHH can 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

[toc] | [prev] | [next] | [standalone]

#122384

On 6/28/2025 11:46 AM, olcott wrote:
> On 6/28/2025 10:39 AM, dbush wrote:
>> On 6/28/2025 11:30 AM, olcott wrote:
>>> On 6/28/2025 10:21 AM, dbush wrote:
>>>> On 6/28/2025 11:17 AM, olcott wrote:
>>>>> On 6/28/2025 10:14 AM, dbush wrote:
>>>>>> On 6/28/2025 11:04 AM, olcott wrote:
>>>>>>> On 6/28/2025 2:43 AM, wij wrote:
>>>>>>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>>>>>>> I am only here for the validation of the behavior
>>>>>>>>> of DDD correctly simulated by HHH.
>>>>>>>>
>>>>>>>> The definition of HHH is missing.
>>>>>>>
>>>>>>> The definition is specified in this part that you
>>>>>>> dishonestly erased:
>>>>>>>
>>>>>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>>>>>  > 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.
>>>>>>>
>>>>>>
>>>>>> The dishonest one here is YOU, as it was not wij who snipped the 
>>>>>> below in his reply but YOU:
>>>>>>
>>>>>
>>>>> I stop at the first counter-factual mistake so I stop here.
>>>>> Everything else is ignored.
>>>>>
>>>>
>>>> In other words, you INTENTIONALLY don't read things that prove you 
>>>> wrong.
>>>>
>>>
>>> On 6/28/2025 2:43 AM, wij wrote:
>>>  >
>>>  > The definition of HHH is missing.
>>>
>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>  > 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.
>>>  >
>>>
>>> It is a verified fact that the definition of HHH was
>>> provided thus the claim that it was not provided is
>>> counter factual.
>>
>>
>> No, you didn't give a definition of HHH, just gave a vauge incomplete 
>> description of what you think it does.
>>
> 
> It completely defines the generic notion of a simulating
> termination analyzer and
> 
> It specifies every detail about HHH that is required
> to correctly determine whether or not DDD correctly
> simulated by HHH can possibly reach its own simulated
> "return" statement final halt state.
>

But why would you say that when you've admitted on the record (see 
below) that DDD is not in fact correctly simulated by HHH?


On 5/5/2025 8:24 AM, dbush wrote:
 > On 5/4/2025 11:03 PM, dbush wrote:
 >> On 5/4/2025 10:05 PM, olcott wrote:
 >>> On 5/4/2025 7:23 PM, Richard Damon wrote:
 >>>> But HHH doesn't correct emulated DD by those rules, as those rules
 >>>> do not allow HHH to stop its emulation,
 >>>
 >>> Sure they do you freaking moron...
 >>
 >> Then show where in the Intel instruction manual that the execution of
 >> any instruction other than a HLT is allowed to stop instead of
 >> executing the next instruction.
 >>
 >> Failure to do so in your next reply, or within one hour of your next
 >> post on this newsgroup, will be taken as you official on-the-record
 >> admission that there is no such allowance and that HHH does NOT
 >> correctly simulate DD.
 >
 > Let the record show that Peter Olcott made the following post in this
 > newsgroup after the above message:
 >
 > On 5/4/2025 11:04 PM, olcott wrote:
 >  > D *WOULD NEVER STOP RUNNING UNLESS*
 >  > indicates that professor Sipser was agreeing
 >  > to hypotheticals AS *NOT CHANGING THE INPUT*
 >  >
 >  > You are taking
 >  > *WOULD NEVER STOP RUNNING UNLESS*
 >  > to mean *NEVER STOPS RUNNING* that is incorrect.
 >
 > And has made no attempt after over 9 hours to show where in the Intel
 > instruction manual that execution is allowed to stop after any
 > instruction other than HLT.
 >
 > Therefore, as per the above criteria:
 >
 > LET THE RECORD SHOW
 >
 > That Peter Olcott
 >
 > Has *officially* admitted
 >
 > That DD is NOT correctly simulated by HHH


>> What is is a verified fact that you openly and blatantly lied about wij 
>> erasing your description when it was in fact you yourself that did it.
>> 

That you made no attempt to refute the above and in fact dishonestly 
erased it constitutes your admission that you were lying and will in 
fact lie about the simplest of things that can be easily verified as false.

This demonstrates to all that nothing you say can be taken seriously.

[toc] | [prev] | [next] | [standalone]

#122385

On 6/28/2025 10:52 AM, dbush wrote:
> On 6/28/2025 11:46 AM, olcott wrote:
>> On 6/28/2025 10:39 AM, dbush wrote:
>>> On 6/28/2025 11:30 AM, olcott wrote:
>>>> On 6/28/2025 10:21 AM, dbush wrote:
>>>>> On 6/28/2025 11:17 AM, olcott wrote:
>>>>>> On 6/28/2025 10:14 AM, dbush wrote:
>>>>>>> On 6/28/2025 11:04 AM, olcott wrote:
>>>>>>>> On 6/28/2025 2:43 AM, wij wrote:
>>>>>>>>> On Fri, 2025-06-27 at 14:36 -0500, olcott wrote:
>>>>>>>>>> I am only here for the validation of the behavior
>>>>>>>>>> of DDD correctly simulated by HHH.
>>>>>>>>>
>>>>>>>>> The definition of HHH is missing.
>>>>>>>>
>>>>>>>> The definition is specified in this part that you
>>>>>>>> dishonestly erased:
>>>>>>>>
>>>>>>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>>>>>>  > 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.
>>>>>>>>
>>>>>>>
>>>>>>> The dishonest one here is YOU, as it was not wij who snipped the 
>>>>>>> below in his reply but YOU:
>>>>>>>
>>>>>>
>>>>>> I stop at the first counter-factual mistake so I stop here.
>>>>>> Everything else is ignored.
>>>>>>
>>>>>
>>>>> In other words, you INTENTIONALLY don't read things that prove you 
>>>>> wrong.
>>>>>
>>>>
>>>> On 6/28/2025 2:43 AM, wij wrote:
>>>>  >
>>>>  > The definition of HHH is missing.
>>>>
>>>> On 6/27/2025 2:36 PM, olcott wrote:
>>>>  > 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.
>>>>  >
>>>>
>>>> It is a verified fact that the definition of HHH was
>>>> provided thus the claim that it was not provided is
>>>> counter factual.
>>>
>>>
>>> No, you didn't give a definition of HHH, just gave a vauge incomplete 
>>> description of what you think it does.
>>>
>>
>> It completely defines the generic notion of a simulating
>> termination analyzer and
>>
>> It specifies every detail about HHH that is required
>> to correctly determine whether or not DDD correctly
>> simulated by HHH can possibly reach its own simulated
>> "return" statement final halt state.
>>
> 
> But why would you say that when you've admitted on the record (see 
> below) that DDD is not in fact correctly simulated by HHH?
> 

*I am not going to tolerate any misdirection to any other points*

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

The only point relevant to this forum is that 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

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | comp.lang.c++

csiph-web