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

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

Will keep posting this every day until someone answers truthfully

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

  Will keep posting this every day until someone answers truthfully olcott <polcott333@gmail.com> - 2025-11-13 18:36 -0600
    Re: Will keep posting this every day until someone answers truthfully olcott <polcott333@gmail.com> - 2025-11-13 18:57 -0600
      Re: Will keep posting this every day until someone answers truthfully Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-14 02:32 +0000
        Re: Will keep posting this every day until someone answers truthfully olcott <polcott333@gmail.com> - 2025-11-13 20:38 -0600
          Re: Will keep posting this every day until someone answers truthfully Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-14 06:35 +0000
            Re: Will keep posting this every day until someone answers truthfully olcott <polcott333@gmail.com> - 2025-11-14 08:13 -0600
              Re: Will keep posting this every day until someone answers truthfully Kaz Kylheku <643-408-1753@kylheku.com> - 2025-11-14 18:01 +0000
                Re: Will keep posting this every day until someone answers truthfully olcott <polcott333@gmail.com> - 2025-11-14 12:19 -0600
    Re: Will keep posting this every day until someone answers truthfully olcott <polcott333@gmail.com> - 2025-11-13 20:39 -0600
    Re: Will keep posting this every day until someone answers truthfully Bonita Montero <Bonita.Montero@gmail.com> - 2025-11-14 09:38 +0100

#123000 — Will keep posting this every day until someone answers truthfully

int H(char* P);

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

int main()
{
   H(D);
}

Answer only on the basis of performing the
actual simulation of D simulated by H.

When N statements of D are simulated by H
according to the semantics of the C programming
language can the simulated D reach its own "return"
statement final halt state for any value of N?

If I have to keep posting this every day for
the next ten years I will.

I have been asking for five minutes of someone's
time and they spend thousands of hours dodging this
over more than three years.




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

#123001

On 11/13/2025 6:45 PM, Kaz Kylheku wrote:
> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>> int H(char* P);
>>
>> int D()
>> {
>>     int Halt_Status = H(D);
>>     if (Halt_Status)
>>       HERE: goto HERE;
>>     return Halt_Status;
>> }
>>
>> int main()
>> {
>>     H(D);
>> }
>>
>> Answer only on the basis of performing the
>> actual simulation of D simulated by H.
>>
>> When N statements of D are simulated by H
>> according to the semantics of the C programming
>> language can the simulated D reach its own "return"
>> statement final halt state for any value of N?
> 
> Positively not. Provided that H returns 0 after the N steps, D reaches
> its halt state in N + k steps for some k > 0. Definitely not in the N
> steps simulated by H.
> 

void Infinite_Recursion(int N)
{
   Infinite_Recursion(N);
   printf("Execution never gets here!");
}

So you still don't understand that when H sees
that D calls the same function twice in sequence
with the same arguments and has no conditional
code inbetween its invocation and this function
call that this is isomorphic to infinite recursion?

> But anyway, D terminates in N + k steps, showing that the 0 return
> is incorrect. The fact that H only makes it to N, and then returns
> the wrong value, is H's problem, and has no bearing on whether D
> terminates---except to the extent that D's termination depends on
> H returning 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]

#123002

On 2025-11-14, olcott <polcott333@gmail.com> wrote:
> So you still don't understand that when H sees
> that D calls the same function twice in sequence
> with the same arguments and has no conditional
> code inbetween its invocation and this function
> call that this is isomorphic to infinite recursion?

No. Obvious counterexample:

void D(void)
{
  printf("calling this twice\n");
  // no conditionals here
  printf("calling this twice\n");
}

You're simply not able to run a simple specification through your head
to identify the ways in which it might not reflect your intent.

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

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

#123003

On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>> So you still don't understand that when H sees
>> that D calls the same function twice in sequence
>> with the same arguments and has no conditional
>> code inbetween its invocation and this function
>> call that this is isomorphic to infinite recursion?
> 
> No. Obvious counterexample:
> 
> void D(void)
> {
>    printf("calling this twice\n");
>    // no conditionals here
>    printf("calling this twice\n");
> }
> 
> You're simply not able to run a simple specification through your head
> to identify the ways in which it might not reflect your intent.
> 

Why do you post such ridiculous nonsense?
Are you a complete jackass or only partial?

This is my life's work and you baselessly
denigrate it with stupid shit like resuming
infinite recursion will cause it to halt.


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

#123007

On 2025-11-14, olcott <polcott333@gmail.com> wrote:
> On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
>> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>>> So you still don't understand that when H sees
>>> that D calls the same function twice in sequence
>>> with the same arguments and has no conditional
>>> code inbetween its invocation and this function
>>> call that this is isomorphic to infinite recursion?
>> 
>> No. Obvious counterexample:
>> 
>> void D(void)
>> {
>>    printf("calling this twice\n");
>>    // no conditionals here
>>    printf("calling this twice\n");
>> }
>> 
>> You're simply not able to run a simple specification through your head
>> to identify the ways in which it might not reflect your intent.
>> 
>
> Why do you post such ridiculous nonsense?

The above "D calls the same function (printf) twice in sequence with the
same arguments ("calling this twice\n") and has no conditional code
inbetween its invocation and this function call". It meets your
criteria; therefore it must be "isomorphic to infinite recursion".

> Are you a complete jackass or only partial?

I'm only conveying to you that the above function meets the words you
have written.

If you didn't intend that, that is your problem. I'm just the messenger.

Such a messenger wouldn't be necessary if you could think for yourself.

> This is my life's work and you baselessly
> denigrate it with stupid shit like resuming
> infinite recursion will cause it to halt.

When your life's work is being reviewed for publication, so that you can
become a renowned computer scientist, is this how you are going to
respond to your reviewers, and do you think that will work?

Your idea that when a decider abandons a simulation and returns zero,
the simuation is "totally killed" does not hold water. Mathematical
entities are never "killed". 

You should be glad that we caught this problem here, before
you took your life's work to academia for publication.

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

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

#123009

On 11/14/2025 12:35 AM, Kaz Kylheku wrote:
> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>> On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
>>> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>>>> So you still don't understand that when H sees
>>>> that D calls the same function twice in sequence
>>>> with the same arguments and has no conditional
>>>> code inbetween its invocation and this function
>>>> call that this is isomorphic to infinite recursion?
>>>
>>> No. Obvious counterexample:
>>>
>>> void D(void)
>>> {
>>>     printf("calling this twice\n");
>>>     // no conditionals here
>>>     printf("calling this twice\n");
>>> }
>>>
>>> You're simply not able to run a simple specification through your head
>>> to identify the ways in which it might not reflect your intent.
>>>
>>
>> Why do you post such ridiculous nonsense?
> 
> The above "D calls the same function (printf) twice in sequence with the
> same arguments ("calling this twice\n") and has no conditional code
> inbetween its invocation and this function call". It meets your
> criteria; therefore it must be "isomorphic to infinite recursion".
> 
>> Are you a complete jackass or only partial?
> 
> I'm only conveying to you that the above function meets the words you
> have written.
> 

OK then I apologize.

> If you didn't intend that, that is your problem. I'm just the messenger.
> 
> Such a messenger wouldn't be necessary if you could think for yourself.
> 

https://github.com/plolcott/x86utm/blob/master/Halt7.c
I forgot a detail on line 996

Calls the same function from the same machine address
with no conditional branches in between its invocation
and this function call.

>> This is my life's work and you baselessly
>> denigrate it with stupid shit like resuming
>> infinite recursion will cause it to halt.
> 
> When your life's work is being reviewed for publication, so that you can
> become a renowned computer scientist, is this how you are going to
> respond to your reviewers, and do you think that will work?
> 

If they mistreated me I may be much more harsh.

> Your idea that when a decider abandons a simulation and returns zero,
> the simuation is "totally killed" does not hold water. Mathematical
> entities are never "killed".
> 

The above non-halting behavior axiom is correct.
It conclusively proves the D simulated by H cannot
possibly ever reach its own simulated "return"
statement.

> You should be glad that we caught this problem here, before
> you took your life's work to academia for publication.
> 

No one is going to publish my work on the halting
problem. Once they see the title of the paper they
dismiss it as ridiculous.

LLM systems can immediately verify that it is
totally correct and they prove that they have
the equivalent of human expert understanding
many different ways.

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

#123010

On 2025-11-14, olcott <polcott333@gmail.com> wrote:
> On 11/14/2025 12:35 AM, Kaz Kylheku wrote:
>> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>>> On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
>>>> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>>>>> So you still don't understand that when H sees
>>>>> that D calls the same function twice in sequence
>>>>> with the same arguments and has no conditional
>>>>> code inbetween its invocation and this function
>>>>> call that this is isomorphic to infinite recursion?
>>>>
>>>> No. Obvious counterexample:
>>>>
>>>> void D(void)
>>>> {
>>>>     printf("calling this twice\n");
>>>>     // no conditionals here
>>>>     printf("calling this twice\n");
>>>> }
>>>>
>>>> You're simply not able to run a simple specification through your head
>>>> to identify the ways in which it might not reflect your intent.
>>>>
>>>
>>> Why do you post such ridiculous nonsense?
>> 
>> The above "D calls the same function (printf) twice in sequence with the
>> same arguments ("calling this twice\n") and has no conditional code
>> inbetween its invocation and this function call". It meets your
>> criteria; therefore it must be "isomorphic to infinite recursion".
>> 
>>> Are you a complete jackass or only partial?
>> 
>> I'm only conveying to you that the above function meets the words you
>> have written.
>> 
>
> OK then I apologize.

My eyes must be deceiving me.

>> If you didn't intend that, that is your problem. I'm just the messenger.
>> 
>> Such a messenger wouldn't be necessary if you could think for yourself.
>> 
>
> https://github.com/plolcott/x86utm/blob/master/Halt7.c
> I forgot a detail on line 996
>
> Calls the same function from the same machine address
> with no conditional branches in between its invocation
> and this function call.

Now suppose that we wrongly place execution events from all
threads into a single buffer.

It can now happen like this:

void D(void)
{
   (void) thread_create(D);
   thread_exit(0);
}

main()
{
   (void) thread_create(D);
}

The repeated call in question is D calling thread_create.

The call happens multiple times, from the same address, without
intervening conditional instructions (assuming we do not
trace system functions thread_create and thread_exit).

In our single trace buffer, it /appears/ to meet the conditions for
identifying runaway recursion.

Yet, do you not see that the threads are all terminating?

Every single new thread dispatched to D creates a new thread, which is
an asynchronous action, and then promptly terminates.

The /process/ will keep spawning new threads and fail to terminate.  But
that's not the question. When we ask whether D terminates, we are not
asking whether D is surrounded by a reality which terminates.

>> Your idea that when a decider abandons a simulation and returns zero,
>> the simuation is "totally killed" does not hold water. Mathematical
>> entities are never "killed".
>> 
>
> The above non-halting behavior axiom is correct.
> It conclusively proves the D simulated by H cannot
> possibly ever reach its own simulated "return"
> statement.

It doesn't. What is correct is the trick in the halting proof, that no
decider could be correct when deciding its diagonal case.

Those who are skeptical can dissect into particular complex cases to see
how they play out: i.e. to articulate in more detail why such and such a
diagonal pair case is incorrect. It is largely moot.

In your case, your logic is incorrect even for non-diagonal cases,
such as:

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

For this non-diagonal case, your HHH could return 1 and be correct.
DDD does not behave opposite to the 1 return value; it confirms it.

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

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

#123011

On 11/14/2025 12:01 PM, Kaz Kylheku wrote:
> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>> On 11/14/2025 12:35 AM, Kaz Kylheku wrote:
>>> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>>>> On 11/13/2025 8:32 PM, Kaz Kylheku wrote:
>>>>> On 2025-11-14, olcott <polcott333@gmail.com> wrote:
>>>>>> So you still don't understand that when H sees
>>>>>> that D calls the same function twice in sequence
>>>>>> with the same arguments and has no conditional
>>>>>> code inbetween its invocation and this function
>>>>>> call that this is isomorphic to infinite recursion?
>>>>>
>>>>> No. Obvious counterexample:
>>>>>
>>>>> void D(void)
>>>>> {
>>>>>      printf("calling this twice\n");
>>>>>      // no conditionals here
>>>>>      printf("calling this twice\n");
>>>>> }
>>>>>
>>>>> You're simply not able to run a simple specification through your head
>>>>> to identify the ways in which it might not reflect your intent.
>>>>>
>>>>
>>>> Why do you post such ridiculous nonsense?
>>>
>>> The above "D calls the same function (printf) twice in sequence with the
>>> same arguments ("calling this twice\n") and has no conditional code
>>> inbetween its invocation and this function call". It meets your
>>> criteria; therefore it must be "isomorphic to infinite recursion".
>>>
>>>> Are you a complete jackass or only partial?
>>>
>>> I'm only conveying to you that the above function meets the words you
>>> have written.
>>>
>>
>> OK then I apologize.
> 
> My eyes must be deceiving me.
> 
>>> If you didn't intend that, that is your problem. I'm just the messenger.
>>>
>>> Such a messenger wouldn't be necessary if you could think for yourself.
>>>
>>
>> https://github.com/plolcott/x86utm/blob/master/Halt7.c
>> I forgot a detail on line 996
>>
>> Calls the same function from the same machine address
>> with no conditional branches in between its invocation
>> and this function call.
> 
> Now suppose that we wrongly place execution events from all
> threads into a single buffer.
> 
> It can now happen like this:
> 
> void D(void)
> {
>     (void) thread_create(D);
>     thread_exit(0);
> }
> 
> main()
> {
>     (void) thread_create(D);
> }
> 
> The repeated call in question is D calling thread_create.
> 
> The call happens multiple times, from the same address, without
> intervening conditional instructions (assuming we do not
> trace system functions thread_create and thread_exit).
> 
> In our single trace buffer, it /appears/ to meet the conditions for
> identifying runaway recursion.
> 
> Yet, do you not see that the threads are all terminating?
> 
> Every single new thread dispatched to D creates a new thread, which is
> an asynchronous action, and then promptly terminates.
> 
> The /process/ will keep spawning new threads and fail to terminate.  But
> that's not the question. When we ask whether D terminates, we are not
> asking whether D is surrounded by a reality which terminates.
> 
>>> Your idea that when a decider abandons a simulation and returns zero,
>>> the simuation is "totally killed" does not hold water. Mathematical
>>> entities are never "killed".
>>>
>>
>> The above non-halting behavior axiom is correct.
>> It conclusively proves the D simulated by H cannot
>> possibly ever reach its own simulated "return"
>> statement.
> 
> It doesn't. What is correct is the trick in the halting proof, that no
> decider could be correct when deciding its diagonal case.
> 
> Those who are skeptical can dissect into particular complex cases to see
> how they play out: i.e. to articulate in more detail why such and such a
> diagonal pair case is incorrect. It is largely moot.
> 
> In your case, your logic is incorrect even for non-diagonal cases,
> such as:
> 
>    void DDD(void) {
>       HHH(DDD);
>       return;
>    }
> 
> For this non-diagonal case, your HHH could return 1 and be correct.
> DDD does not behave opposite to the 1 return value; it confirms it.
> 


On 5/8/2025 8:30 PM, Keith Thompson wrote:
 > Assuming that HHH(DDD) "correctly simulates" DDD, and assuming it
 > does nothing else, your code would be equivalent to this:
 >
 >      void DDD(void) {
 >          DDD();
 >          return;
 >      }
 >
 > Then the return statement (which is unnecessary anyway) will never be
 > reached.  In practice, the program will likely crash due to a stack
 > overflow, unless the compiler implements tail-call optimization, in
 > which case the program might just run forever -- which also means the
 > unnecessary return statement will never be reached.
 >

news://text.giganews.com/87seled0zy.fsf@nosuchdomain.example.com

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

#123004

int H(char* P);

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

int main()
{
   H(D);
}

Answer only on the basis of performing the
actual simulation of D simulated by H.

When N statements of D are simulated by H
according to the semantics of the C programming
language can the simulated D reach its own "return"
statement final halt state for any value of N?

If I have to keep posting this every day for
the next ten years I will.

I have been asking for five minutes of someone's
time and they spend thousands of hours dodging this
over more than three years.

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

#123008

You think in loops, not the others.

Am 14.11.2025 um 01:36 schrieb olcott:
> int H(char* P);
>
> int D()
> {
>   int Halt_Status = H(D);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   H(D);
> }
>
> Answer only on the basis of performing the
> actual simulation of D simulated by H.
>
> When N statements of D are simulated by H
> according to the semantics of the C programming
> language can the simulated D reach its own "return"
> statement final halt state for any value of N?
>
> If I have to keep posting this every day for
> the next ten years I will.
>
> I have been asking for five minutes of someone's
> time and they spend thousands of hours dodging this
> over more than three years.
>
>
>
>

[toc] | [prev] | [standalone]

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

csiph-web