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

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

polcott agrees the Kaz is a damned liar --- DD simulated by HHH

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

This discussion starts older than the indexed window; earlier articles aren't shown. The article labeled Started by below is the oldest one visible, not the original post.

Contents

  polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-20 17:24 -0600
    Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-21 02:42 +0000
      polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-20 20:50 -0600
        Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-21 04:12 +0000
        Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-20 22:41 -0600
          Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-21 12:15 -0600
            Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-21 18:22 +0000
            Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-21 19:18 +0000
              Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-21 13:33 -0600
                Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-21 22:05 +0000
                  Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <NoOne@NoWhere.com> - 2025-11-21 23:14 -0600
                    Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH Richard Heathfield <rjh@cpax.org.uk> - 2025-11-22 05:39 +0000
                      Re: polcott agrees the Kaz is a damned liar --- DD simulated by HHH olcott <polcott333@gmail.com> - 2025-11-22 07:05 -0600
                    Glossary of names in my termination analyzer system olcott <polcott333@gmail.com> - 2025-11-22 22:50 -0600

#123031 — polcott agrees the Kaz is a damned liar --- DD simulated by HHH

On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>> On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>> On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>>>> The sound basis of this reasoning is the
>>>>>> semantics of the C programming language.
>>>>>
>>>>> ... and, note,
>>>> that you dishonestly erased most of the context
>>>
>>> That's just the same pseudo-code snppet you've posted
>>> hundreds of times.
>>>
>>
>> The idea is that I will keep repeating this
>> until you pay attention
>>
>> int DD()
>> {
>>     int Halt_Status = HHH(DD);
>>     if (Halt_Status)
>>       HERE: goto HERE;
>>     return Halt_Status;
>> }
>>
>> int main()
>> {
>>     HHH(DD);
>> }
>>
> 
> I've given ths an incredible amount of attention.
> 
>> HHH simulates DD that calls HHH(DD)
>> that simulates DD that calls HHH(DD)...
> 
> If HHH(DD) returns 0, it's this;
> 
>     HHH simulates DD that calls HHH(DD)
>       - that simulates DD that calls HHH(DD)...
>           - that simulates DD that calls HHH(DD)...
>           - but only partially, returning 0.
>           - such that DD terminates.
>       - but only partially, returning 0.
>       - such that DD terminates.
> 
> Adding another level:
> 
>     HHH simulates DD that calls HHH(DD)
>       - that simulates DD that calls HHH(DD)...
>           - that simulates DD that calls HHH(DD)...
>              - that simulates DD that calls HHH(DD)...
>                - that ...
>                  - that ...
>                    - that ...
>              - but only partially, returning 0.

Such a jackass trying to get away with saying
that simulated inputs that cannot possibly stop
running unless aborted terminate normally.

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then...

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. PO really /has/ an H
 > (it's trivial to do for this one case) that correctly determines
 > that P(P) *would* never stop running *unless* aborted.

*You are not stupid so that only leaves liar*
https://www.nongnu.org/txr/

>              - such that DD terminates.
>           - but only partially, returning 0.
>           - such that DD terminates.
>       - but only partially, returning 0.
>       - such that DD terminates.
> 
> Infinite simulation tower: finite DD's.
> 
> Since you don't grok this but I do, obviously the one who has
> paid more attention is me.
> 


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

[toc] | [next] | [standalone]

#123033

On 2025-11-20, olcott <polcott333@gmail.com> wrote:
> On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>> On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
>>>>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>>>>> The sound basis of this reasoning is the
>>>>>>> semantics of the C programming language.
>>>>>>
>>>>>> ... and, note,
>>>>> that you dishonestly erased most of the context
>>>>
>>>> That's just the same pseudo-code snppet you've posted
>>>> hundreds of times.
>>>>
>>>
>>> The idea is that I will keep repeating this
>>> until you pay attention
>>>
>>> int DD()
>>> {
>>>     int Halt_Status = HHH(DD);
>>>     if (Halt_Status)
>>>       HERE: goto HERE;
>>>     return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>     HHH(DD);
>>> }
>>>
>> 
>> I've given ths an incredible amount of attention.
>> 
>>> HHH simulates DD that calls HHH(DD)
>>> that simulates DD that calls HHH(DD)...
>> 
>> If HHH(DD) returns 0, it's this;
>> 
>>     HHH simulates DD that calls HHH(DD)
>>       - that simulates DD that calls HHH(DD)...
>>           - that simulates DD that calls HHH(DD)...
>>           - but only partially, returning 0.
>>           - such that DD terminates.
>>       - but only partially, returning 0.
>>       - such that DD terminates.
>> 
>> Adding another level:
>> 
>>     HHH simulates DD that calls HHH(DD)
>>       - that simulates DD that calls HHH(DD)...
>>           - that simulates DD that calls HHH(DD)...
>>              - that simulates DD that calls HHH(DD)...
>>                - that ...
>>                  - that ...
>>                    - that ...
>>              - but only partially, returning 0.
>
> Such a jackass trying to get away with saying

All you have is personal attacks, rather than reasoning
and following code and execution traces.

> that simulated inputs that cannot possibly stop
> running unless aborted terminate normally.

Self-assurance without a shred of support.

><MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>    If simulating halt decider H correctly simulates its input D
>    until H correctly determines that its simulated D would never
>    stop running unless aborted then...

I also agreed to these words, at least four times.

I also agree with "If the is_even() function correctly processes
its input 42 until it correctly determines that it would
be odd unless divided by two without a remainder ..."

> *You are not stupid so that only leaves liar*

Those are the options only under the assumption that YOU are not stupid!

See, you are not smart enough to even analyze all the cases in
this particular matter.

The more or less complete case analyis is this:

Either:

- (a) you are stupid; or
- (b) you are pretending to be stupid; or
- (c) everyone else is stupid; or
- (d) everyone else is faking.

I have reproduced my claims in a small amount of code, which you can
inspect, build and run.

If liars encode their claims in published code, you can find the lie.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

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

#123034

On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>> On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>> On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
>>>>>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>>>>>> The sound basis of this reasoning is the
>>>>>>>> semantics of the C programming language.
>>>>>>>
>>>>>>> ... and, note,
>>>>>> that you dishonestly erased most of the context
>>>>>
>>>>> That's just the same pseudo-code snppet you've posted
>>>>> hundreds of times.
>>>>>
>>>>
>>>> The idea is that I will keep repeating this
>>>> until you pay attention
>>>>
>>>> int DD()
>>>> {
>>>>      int Halt_Status = HHH(DD);
>>>>      if (Halt_Status)
>>>>        HERE: goto HERE;
>>>>      return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>      HHH(DD);
>>>> }
>>>>
>>>
>>> I've given ths an incredible amount of attention.
>>>
>>>> HHH simulates DD that calls HHH(DD)
>>>> that simulates DD that calls HHH(DD)...
>>>
>>> If HHH(DD) returns 0, it's this;
>>>
>>>      HHH simulates DD that calls HHH(DD)
>>>        - that simulates DD that calls HHH(DD)...
>>>            - that simulates DD that calls HHH(DD)...
>>>            - but only partially, returning 0.
>>>            - such that DD terminates.
>>>        - but only partially, returning 0.
>>>        - such that DD terminates.
>>>
>>> Adding another level:
>>>
>>>      HHH simulates DD that calls HHH(DD)
>>>        - that simulates DD that calls HHH(DD)...
>>>            - that simulates DD that calls HHH(DD)...
>>>               - that simulates DD that calls HHH(DD)...
>>>                 - that ...
>>>                   - that ...
>>>                     - that ...
>>>               - but only partially, returning 0.
>>
>> Such a jackass trying to get away with saying
> 
> All you have is personal attacks, rather than reasoning
> and following code and execution traces.
> 
>> that simulated inputs that cannot possibly stop
>> running unless aborted terminate normally.
> 
> Self-assurance without a shred of support.
> 
>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>     If simulating halt decider H correctly simulates its input D
>>     until H correctly determines that its simulated D would never
>>     stop running unless aborted then...
> 
> I also agreed to these words, at least four times.
> 

I doubt this. Prove it with a
Time/Date stamp and a Message ID.

It must be actual agreement with those
actual words or you are still a liar.

It can't be some bullshit that I didn't
interpret them correctly, they only have
one single meaning.

You have proven that you are smart
https://www.nongnu.org/txr/
Now prove that you are not a liar.

-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123035

On 2025-11-21, olcott <polcott333@gmail.com> wrote:
> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>> On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
>>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>>> On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
>>>>>>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>>>>>>> The sound basis of this reasoning is the
>>>>>>>>> semantics of the C programming language.
>>>>>>>>
>>>>>>>> ... and, note,
>>>>>>> that you dishonestly erased most of the context
>>>>>>
>>>>>> That's just the same pseudo-code snppet you've posted
>>>>>> hundreds of times.
>>>>>>
>>>>>
>>>>> The idea is that I will keep repeating this
>>>>> until you pay attention
>>>>>
>>>>> int DD()
>>>>> {
>>>>>      int Halt_Status = HHH(DD);
>>>>>      if (Halt_Status)
>>>>>        HERE: goto HERE;
>>>>>      return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>      HHH(DD);
>>>>> }
>>>>>
>>>>
>>>> I've given ths an incredible amount of attention.
>>>>
>>>>> HHH simulates DD that calls HHH(DD)
>>>>> that simulates DD that calls HHH(DD)...
>>>>
>>>> If HHH(DD) returns 0, it's this;
>>>>
>>>>      HHH simulates DD that calls HHH(DD)
>>>>        - that simulates DD that calls HHH(DD)...
>>>>            - that simulates DD that calls HHH(DD)...
>>>>            - but only partially, returning 0.
>>>>            - such that DD terminates.
>>>>        - but only partially, returning 0.
>>>>        - such that DD terminates.
>>>>
>>>> Adding another level:
>>>>
>>>>      HHH simulates DD that calls HHH(DD)
>>>>        - that simulates DD that calls HHH(DD)...
>>>>            - that simulates DD that calls HHH(DD)...
>>>>               - that simulates DD that calls HHH(DD)...
>>>>                 - that ...
>>>>                   - that ...
>>>>                     - that ...
>>>>               - but only partially, returning 0.
>>>
>>> Such a jackass trying to get away with saying
>> 
>> All you have is personal attacks, rather than reasoning
>> and following code and execution traces.
>> 
>>> that simulated inputs that cannot possibly stop
>>> running unless aborted terminate normally.
>> 
>> Self-assurance without a shred of support.
>> 
>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>     If simulating halt decider H correctly simulates its input D
>>>     until H correctly determines that its simulated D would never
>>>     stop running unless aborted then...
>> 
>> I also agreed to these words, at least four times.
>> 
>
> I doubt this. Prove it with a
> Time/Date stamp and a Message ID.

Go to Google Groups and search.

> It must be actual agreement with those
> actual words or you are still a liar.

From the perspective of the aborting H, if we consider how the behavior
would change if H were redesigned not to abort, we have to conclude
that the D test case would thereby be redesigned not to terminate. And
furthermore that H(D) wouldn't return, so the revised D doesn't even
reach the "do-the-opposite" code. (Of course, those are a different H
and D that must be given different names.)

I don't agree with what you are reading into that; but the statement
Sipser supposedly agreed wth doesn't actually read anything into
anything.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

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

#123036

On 11/20/2025 10:13 PM, Kaz Kylheku wrote:
> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>> On 11/20/2025 4:10 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/19/2025 10:42 PM, Kaz Kylheku wrote:
>>>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 11/19/2025 3:41 PM, Kaz Kylheku wrote:
>>>>>>>>> On 2025-11-19, olcott <polcott333@gmail.com> wrote:
>>>>>>>>>> The sound basis of this reasoning is the
>>>>>>>>>> semantics of the C programming language.
>>>>>>>>>
>>>>>>>>> ... and, note,
>>>>>>>> that you dishonestly erased most of the context
>>>>>>>
>>>>>>> That's just the same pseudo-code snppet you've posted
>>>>>>> hundreds of times.
>>>>>>>
>>>>>>
>>>>>> The idea is that I will keep repeating this
>>>>>> until you pay attention
>>>>>>
>>>>>> int DD()
>>>>>> {
>>>>>>       int Halt_Status = HHH(DD);
>>>>>>       if (Halt_Status)
>>>>>>         HERE: goto HERE;
>>>>>>       return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>       HHH(DD);
>>>>>> }
>>>>>>
>>>>>
>>>>> I've given ths an incredible amount of attention.
>>>>>
>>>>>> HHH simulates DD that calls HHH(DD)
>>>>>> that simulates DD that calls HHH(DD)...
>>>>>
>>>>> If HHH(DD) returns 0, it's this;
>>>>>
>>>>>       HHH simulates DD that calls HHH(DD)
>>>>>         - that simulates DD that calls HHH(DD)...
>>>>>             - that simulates DD that calls HHH(DD)...
>>>>>             - but only partially, returning 0.
>>>>>             - such that DD terminates.
>>>>>         - but only partially, returning 0.
>>>>>         - such that DD terminates.
>>>>>
>>>>> Adding another level:
>>>>>
>>>>>       HHH simulates DD that calls HHH(DD)
>>>>>         - that simulates DD that calls HHH(DD)...
>>>>>             - that simulates DD that calls HHH(DD)...
>>>>>                - that simulates DD that calls HHH(DD)...
>>>>>                  - that ...
>>>>>                    - that ...
>>>>>                      - that ...
>>>>>                - but only partially, returning 0.
>>>>
>>>> Such a jackass trying to get away with saying
>>>
>>> All you have is personal attacks, rather than reasoning
>>> and following code and execution traces.
>>>
>>>> that simulated inputs that cannot possibly stop
>>>> running unless aborted terminate normally.
>>>
>>> Self-assurance without a shred of support.
>>>
>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>      If simulating halt decider H correctly simulates its input D
>>>>      until H correctly determines that its simulated D would never
>>>>      stop running unless aborted then...
>>>
>>> I also agreed to these words, at least four times.
>>>
>>
>> I doubt this. Prove it with a
>> Time/Date stamp and a Message ID.
> 
> Go to Google Groups and search.
> 

>> It must be actual agreement with those
>> actual words or you are still a liar.
> 
>  From the perspective of the aborting H, if we consider how the behavior
> would change if H were redesigned not to abort, we have to conclude
> that the D test case would thereby be redesigned not to terminate. And
> furthermore that H(D) wouldn't return, so the revised D doesn't even
> reach the "do-the-opposite" code. (Of course, those are a different H
> and D that must be given different names.)
> 

It proves that the input to H(D) specifies
non-halting behavior.

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.

We stay in the C/C++ groups until we have
complete mutual agreement on the C. As soon
as that occurs we leave these groups.

> I don't agree with what you are reading into that; but the statement
> Sipser supposedly agreed wth doesn't actually read anything into
> anything.
> 
> [I see you annoyingly added the comp.lang.c and comp.lang.c++ newsgroups
> to the crossposts. I didn't catch it, but I'm double checking and
> superseding my articles to remove that.]
> 


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123039

On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>> No, it states that D would be non-halting in the hypothetical situtation
>>> in whch H neglected to abort, and just kept simulating.
>>>
>>
>> HHH has no idea that DD is calling itself, HHH
>> can only see that DD is calling the same function
>> twice in sequence with no conditional branch in
>> DD to stop this from infinitely repeating.
> 
> It's been explained to you that ths doesn't happen.
> 
> Any given invocation of DD makes only one call to HHH
> (as anyone can plainly see from its simple code of several
> lines!)
> 

Those double-talk weasel words count as lying within
the context of this.

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
 > On 2025-11-20, olcott <polcott333@gmail.com> wrote:
 >> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
 >>     If simulating halt decider H correctly simulates its input D
 >>     until H correctly determines that its simulated D would never
 >>     stop running unless aborted then...
 >
 > I also agreed to these words, at least four times.
 >

The above proves that the input to H(D) does specify
non-halting behavior.

Turing machine deciders only compute a mapping from
their [finite string] inputs to an accept or reject
state on the basis that this [finite string] input
specifies or fails to specify a semantic or syntactic
property.


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123040

On 2025-11-21, olcott <polcott333@gmail.com> wrote:
> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>> No, it states that D would be non-halting in the hypothetical situtation
>>>> in whch H neglected to abort, and just kept simulating.
>>>>
>>>
>>> HHH has no idea that DD is calling itself, HHH
>>> can only see that DD is calling the same function
>>> twice in sequence with no conditional branch in
>>> DD to stop this from infinitely repeating.
>> 
>> It's been explained to you that ths doesn't happen.
>> 
>> Any given invocation of DD makes only one call to HHH
>> (as anyone can plainly see from its simple code of several
>> lines!)
>> 
>
> Those double-talk weasel words count as lying within
> the context of this.
>
> int DD()
> {
>    int Halt_Status = HHH(DD);  
                      
There, that is one call. DD calls HHH exactly once.

HHH does not anything that could call HHH again, including DD.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

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

#123041

On 2025-11-21, olcott <polcott333@gmail.com> wrote:
> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>> No, it states that D would be non-halting in the hypothetical situtation
>>>> in whch H neglected to abort, and just kept simulating.
>>>>
>>>
>>> HHH has no idea that DD is calling itself, HHH
>>> can only see that DD is calling the same function
>>> twice in sequence with no conditional branch in
>>> DD to stop this from infinitely repeating.
>> 
>> It's been explained to you that ths doesn't happen.
>> 
>> Any given invocation of DD makes only one call to HHH
>> (as anyone can plainly see from its simple code of several
>> lines!)
>> 
>
> Those double-talk weasel words count as lying within
> the context of this.
>
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
>
> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
> > On 2025-11-20, olcott <polcott333@gmail.com> wrote:
> >> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
> >>     If simulating halt decider H correctly simulates its input D
> >>     until H correctly determines that its simulated D would never
> >>     stop running unless aborted then...
> >
> > I also agreed to these words, at least four times.
> >
>
> The above proves that the input to H(D) does specify
> non-halting behavior.

All you are communicating is that you have no idea what "prove" means;
where the bar is at for proving something.

> Turing machine deciders only compute a mapping from
> their [finite string] inputs to an accept or reject

Yes, /a/ mapping. There is only one mapping. The mapping is
the abstract halting function.

There are no deciders which compute that mapping, only partial
deciders.

> state on the basis that this [finite string] input
> specifies or fails to specify a semantic or syntactic
> property.

The mapping is a function.  It assigns /one/ value to each 
domain element.  The finite representation D is a domain element
which maps to one truth value.

Yet you claim that HHH1(DD) == 1 and HHH(DD) == 0 are both
right.

That cannot be; the mapping doesn't support it.

It cannot be that two deciders are following a different mapping
such that both can be correct when they contradict each other.

The mapping they must be calculating must correspond to the
halting function. If the disagree, one of the two is not following
the halting functions and is therefore incorrect.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

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

#123042

On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>>> No, it states that D would be non-halting in the hypothetical situtation
>>>>> in whch H neglected to abort, and just kept simulating.
>>>>>
>>>>
>>>> HHH has no idea that DD is calling itself, HHH
>>>> can only see that DD is calling the same function
>>>> twice in sequence with no conditional branch in
>>>> DD to stop this from infinitely repeating.
>>>
>>> It's been explained to you that ths doesn't happen.
>>>
>>> Any given invocation of DD makes only one call to HHH
>>> (as anyone can plainly see from its simple code of several
>>> lines!)
>>>
>>
>> Those double-talk weasel words count as lying within
>> the context of this.
>>
>> int DD()
>> {
>>     int Halt_Status = HHH(DD);
>>     if (Halt_Status)
>>       HERE: goto HERE;
>>     return Halt_Status;
>> }
>>
>> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>      If simulating halt decider H correctly simulates its input D
>>>>      until H correctly determines that its simulated D would never
>>>>      stop running unless aborted then...
>>>
>>> I also agreed to these words, at least four times.
>>>
>>
>> The above proves that the input to H(D) does specify
>> non-halting behavior.
> 
> All you are communicating is that you have no idea what "prove" means;
> where the bar is at for proving something.
> 

A proof is ultimately any conclusion derived by
applying correct semantic entailment to a
self-evidently true basis.

The semantics of C and the above function are the
self-evidently true basis.

The sequence of steps of DD simulated by HHH according
the the semantics of C is the semantic entailment.

This derives the necessary consequence that DD
simulated by HHH would never stop running unless
aborted.


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123043

On 2025-11-21, olcott <polcott333@gmail.com> wrote:
> On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>>>> No, it states that D would be non-halting in the hypothetical situtation
>>>>>> in whch H neglected to abort, and just kept simulating.
>>>>>>
>>>>>
>>>>> HHH has no idea that DD is calling itself, HHH
>>>>> can only see that DD is calling the same function
>>>>> twice in sequence with no conditional branch in
>>>>> DD to stop this from infinitely repeating.
>>>>
>>>> It's been explained to you that ths doesn't happen.
>>>>
>>>> Any given invocation of DD makes only one call to HHH
>>>> (as anyone can plainly see from its simple code of several
>>>> lines!)
>>>>
>>>
>>> Those double-talk weasel words count as lying within
>>> the context of this.
>>>
>>> int DD()
>>> {
>>>     int Halt_Status = HHH(DD);
>>>     if (Halt_Status)
>>>       HERE: goto HERE;
>>>     return Halt_Status;
>>> }
>>>
>>> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>>      If simulating halt decider H correctly simulates its input D
>>>>>      until H correctly determines that its simulated D would never
>>>>>      stop running unless aborted then...
>>>>
>>>> I also agreed to these words, at least four times.
>>>>
>>>
>>> The above proves that the input to H(D) does specify
>>> non-halting behavior.
>> 
>> All you are communicating is that you have no idea what "prove" means;
>> where the bar is at for proving something.
>> 
>
> A proof is ultimately any conclusion derived by
> applying correct semantic entailment to a
> self-evidently true basis.

You've not even began to do anythng of this sort.

> The semantics of C and the above function are the
> self-evidently true basis.

The above function is incomplete. You have to show all of
HHHH, and how exactly it simulates DD, and how it comes to
the conclusion that it should stop doing that and return 0.

Those can all be incorrect, without the "semantics of C"
being violated!

Do you not know that a program can be buggy? Or entirely the wrong
program written to the wrong requirements? Yet completely adhere to the
semantics of its programming language (whch means never doing anything
undefined?)

You've only been a coding technician and not an actual engineer,
that's why you don't know basics like this.

-- 
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

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

#123044

On 11/21/2025 4:05 PM, Kaz Kylheku wrote:
> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>> On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>>>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>>>>> No, it states that D would be non-halting in the hypothetical situtation
>>>>>>> in whch H neglected to abort, and just kept simulating.
>>>>>>>
>>>>>>
>>>>>> HHH has no idea that DD is calling itself, HHH
>>>>>> can only see that DD is calling the same function
>>>>>> twice in sequence with no conditional branch in
>>>>>> DD to stop this from infinitely repeating.
>>>>>
>>>>> It's been explained to you that ths doesn't happen.
>>>>>
>>>>> Any given invocation of DD makes only one call to HHH
>>>>> (as anyone can plainly see from its simple code of several
>>>>> lines!)
>>>>>
>>>>
>>>> Those double-talk weasel words count as lying within
>>>> the context of this.
>>>>
>>>> int DD()
>>>> {
>>>>      int Halt_Status = HHH(DD);
>>>>      if (Halt_Status)
>>>>        HERE: goto HERE;
>>>>      return Halt_Status;
>>>> }
>>>>
>>>> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>>>>>>       If simulating halt decider H correctly simulates its input D
>>>>>>       until H correctly determines that its simulated D would never
>>>>>>       stop running unless aborted then...
>>>>>
>>>>> I also agreed to these words, at least four times.
>>>>>
>>>>
>>>> The above proves that the input to H(D) does specify
>>>> non-halting behavior.
>>>
>>> All you are communicating is that you have no idea what "prove" means;
>>> where the bar is at for proving something.
>>>
>>
>> A proof is ultimately any conclusion derived by
>> applying correct semantic entailment to a
>> self-evidently true basis.
> 
> You've not even began to do anythng of this sort.
> 
>> The semantics of C and the above function are the
>> self-evidently true basis.
> 
> The above function is incomplete. You have to show all of
> HHHH, and how exactly it simulates DD, and how it comes to
> the conclusion that it should stop doing that and return 0.
> 

The combination of the semantics of C
and the source of the function DD provide
all the information needed to specify all
of the details of the steps of DD simulated
by HHH.

> Those can all be incorrect, without the "semantics of C"
> being violated!
> 
> Do you not know that a program can be buggy? Or entirely the wrong
> program written to the wrong requirements? Yet completely adhere to the
> semantics of its programming language (whch means never doing anything
> undefined?)
> 
> You've only been a coding technician and not an actual engineer,
> that's why you don't know basics like this.
> 


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123045

On 22/11/2025 05:14, olcott wrote:
> On 11/21/2025 4:05 PM, Kaz Kylheku wrote:
>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>> On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
>>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>>> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>>>>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>>>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>>>>>> No, it states that D would be non-halting in the 
>>>>>>>> hypothetical situtation
>>>>>>>> in whch H neglected to abort, and just kept simulating.
>>>>>>>>
>>>>>>>
>>>>>>> HHH has no idea that DD is calling itself, HHH
>>>>>>> can only see that DD is calling the same function
>>>>>>> twice in sequence with no conditional branch in
>>>>>>> DD to stop this from infinitely repeating.
>>>>>>
>>>>>> It's been explained to you that ths doesn't happen.
>>>>>>
>>>>>> Any given invocation of DD makes only one call to HHH
>>>>>> (as anyone can plainly see from its simple code of several
>>>>>> lines!)
>>>>>>
>>>>>
>>>>> Those double-talk weasel words count as lying within
>>>>> the context of this.
>>>>>
>>>>> int DD()
>>>>> {
>>>>>      int Halt_Status = HHH(DD);
>>>>>      if (Halt_Status)
>>>>>        HERE: goto HERE;
>>>>>      return Halt_Status;
>>>>> }
>>>>>
>>>>> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 
>>>>>>> 10/13/2022>
>>>>>>>       If simulating halt decider H correctly simulates its 
>>>>>>> input D
>>>>>>>       until H correctly determines that its simulated D 
>>>>>>> would never
>>>>>>>       stop running unless aborted then...
>>>>>>
>>>>>> I also agreed to these words, at least four times.
>>>>>>
>>>>>
>>>>> The above proves that the input to H(D) does specify
>>>>> non-halting behavior.
>>>>
>>>> All you are communicating is that you have no idea what 
>>>> "prove" means;
>>>> where the bar is at for proving something.
>>>>
>>>
>>> A proof is ultimately any conclusion derived by
>>> applying correct semantic entailment to a
>>> self-evidently true basis.
>>
>> You've not even began to do anythng of this sort.
>>
>>> The semantics of C and the above function are the
>>> self-evidently true basis.
>>
>> The above function is incomplete. You have to show all of
>> HHHH, and how exactly it simulates DD, and how it comes to
>> the conclusion that it should stop doing that and return 0.
>>
> 
> The combination of the semantics of C
> and the source of the function DD provide
> all the information needed to specify all
> of the details of the steps of DD simulated
> by HHH.

Not so.

HHH could, for example, contain its own exit() call, in which 
case DD halts, or its own for(;;); loop, in which case DD doesn't 
halt... or even both, in which case it all depends.

Since DD calls HHH, DD's behaviour depends on HHH's behaviour, 
and any analysis of DD's behaviour must therefore include an 
analysis of HHH's behaviour.

What you have to remember about olcott is that not only does he 
have no understanding of DD's specific dependency on HHH (ie 
whether DD halts depends first and foremost on HHH's coin-toss 
decision), but neither does he have any idea of any C function's 
generic dependency on the functions it calls.

Not only is olcott a damned liar, but he's a damned idiot. He is, 
in fact, a fine exemplar of why killfiles were invented. Just 
plonk him and (barring the odd nymshyft) you can be done with him 
for good.

<snip>

-- 
Richard Heathfield
Email: rjh at cpax dot org dot uk
"Usenet is a strange place" - dmr 29 July 1999
Sig line 4 vacant - apply within

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

#123046

On 11/21/2025 11:39 PM, Richard Heathfield wrote:
> On 22/11/2025 05:14, olcott wrote:
>> On 11/21/2025 4:05 PM, Kaz Kylheku wrote:
>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>> On 11/21/2025 1:18 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>>>> On 11/21/2025 11:29 AM, Kaz Kylheku wrote:
>>>>>>> On 2025-11-21, olcott <polcott333@gmail.com> wrote:
>>>>>>>> On 11/20/2025 11:04 PM, Kaz Kylheku wrote:
>>>>>>>>> No, it states that D would be non-halting in the hypothetical 
>>>>>>>>> situtation
>>>>>>>>> in whch H neglected to abort, and just kept simulating.
>>>>>>>>>
>>>>>>>>
>>>>>>>> HHH has no idea that DD is calling itself, HHH
>>>>>>>> can only see that DD is calling the same function
>>>>>>>> twice in sequence with no conditional branch in
>>>>>>>> DD to stop this from infinitely repeating.
>>>>>>>
>>>>>>> It's been explained to you that ths doesn't happen.
>>>>>>>
>>>>>>> Any given invocation of DD makes only one call to HHH
>>>>>>> (as anyone can plainly see from its simple code of several
>>>>>>> lines!)
>>>>>>>
>>>>>>
>>>>>> Those double-talk weasel words count as lying within
>>>>>> the context of this.
>>>>>>
>>>>>> int DD()
>>>>>> {
>>>>>>      int Halt_Status = HHH(DD);
>>>>>>      if (Halt_Status)
>>>>>>        HERE: goto HERE;
>>>>>>      return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> On 11/20/2025 8:42 PM, Kaz Kylheku wrote:
>>>>>>> On 2025-11-20, olcott <polcott333@gmail.com> wrote:
>>>>>>>> <MIT Professor Sipser agreed to ONLY these verbatim words 
>>>>>>>> 10/13/2022>
>>>>>>>>       If simulating halt decider H correctly simulates its input D
>>>>>>>>       until H correctly determines that its simulated D would never
>>>>>>>>       stop running unless aborted then...
>>>>>>>
>>>>>>> I also agreed to these words, at least four times.
>>>>>>>
>>>>>>
>>>>>> The above proves that the input to H(D) does specify
>>>>>> non-halting behavior.
>>>>>
>>>>> All you are communicating is that you have no idea what "prove" means;
>>>>> where the bar is at for proving something.
>>>>>
>>>>
>>>> A proof is ultimately any conclusion derived by
>>>> applying correct semantic entailment to a
>>>> self-evidently true basis.
>>>
>>> You've not even began to do anythng of this sort.
>>>
>>>> The semantics of C and the above function are the
>>>> self-evidently true basis.
>>>
>>> The above function is incomplete. You have to show all of
>>> HHHH, and how exactly it simulates DD, and how it comes to
>>> the conclusion that it should stop doing that and return 0.
>>>
>>
>> The combination of the semantics of C
>> and the source of the function DD provide
>> all the information needed to specify all
>> of the details of the steps of DD simulated
>> by HHH.
> 
> Not so.
> 

<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>

On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. PO really /has/ an H
 > (it's trivial to do for this one case) that correctly determines
 > that P(P) *would* never stop running *unless* aborted.

> HHH could, for example, contain its own exit() call, in which case DD 
> halts, or its own for(;;); loop, in which case DD doesn't halt... or 
> even both, in which case it all depends.
> 
> Since DD calls HHH, DD's behaviour depends on HHH's behaviour, and any 
> analysis of DD's behaviour must therefore include an analysis of HHH's 
> behaviour.
> 
> What you have to remember about olcott is that not only does he have no 
> understanding of DD's specific dependency on HHH (ie whether DD halts 
> depends first and foremost on HHH's coin-toss decision), but neither 
> does he have any idea of any C function's generic dependency on the 
> functions it calls.
> 
> Not only is olcott a damned liar, but he's a damned idiot. He is, in 
> fact, a fine exemplar of why killfiles were invented. Just plonk him and 
> (barring the odd nymshyft) you can be done with him for good.
> 
> <snip>
> 


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

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

#123053 — Glossary of names in my termination analyzer system

On 11/22/2025 10:20 PM, Tristan Wibberley wrote:
> On 23/11/2025 04:07, Kaz Kylheku wrote:
>> I've explicitly asked hm to make a catalog of these names, and describe
>> each one; no response (unsurprisingly).
> 
> Some time ago I suggested he post a regular glossary. It was very
> quickly clear that his communication strategy is making it difficult.
> 
> 

template for hypothetical H and D
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
   If simulating halt decider H correctly simulates its input D
   until H correctly determines that its simulated D would never
   stop running unless aborted then

   H can abort its simulation of D and correctly report that D
   specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words10/13/2022>

https://github.com/plolcott/x86utm/blob/master/Halt7.c

HHH is a fully operational termination analyzer anchored
in the x86 language yet can be construed as simulating C
functions according to the semantics of the C programming
language because the x86 was code translated from C.

HHH1 exactly the same as HHH except that DD does not
call HHH.

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

int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}

int main()
{
   HHH(DD);
}

HHH simulates DD that calls HHH(DD)
that simulates DD that calls HHH(DD)...

HHH1 simulates DD that calls HHH(DD) that
returns to DD that returns to HHH1.

The behavior of DD simulated by HHH1 is the
same as the behavior of DD() executed from main.

The sound basis of this reasoning is the
semantics of the C programming language.


-- 
Copyright 2025 Olcott

My 28 year goal has been to make
"true on the basis of meaning" computable.

[toc] | [prev] | [standalone]

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

csiph-web