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

Groups > comp.theory > #118280 > unrolled thread

Re: Why I need to cross-post to comp.lang.c

Back to article view | Back to comp.theory

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

  Re: Why I need to cross-post to comp.lang.c Mikko <mikko.levanto@iki.fi> - 2025-05-10 10:15 +0300
    Re: Why I need to cross-post to comp.lang.c Richard Heathfield <rjh@cpax.org.uk> - 2025-05-10 11:10 +0100
      Re: Why I need to cross-post to comp.lang.c Richard Damon <richard@damon-family.org> - 2025-05-10 08:30 -0400
    Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED olcott <polcott333@gmail.com> - 2025-05-10 10:13 -0500
      Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED wij <wyniijj5@gmail.com> - 2025-05-10 23:39 +0800
      Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-10 17:47 +0200
      Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Richard Damon <richard@damon-family.org> - 2025-05-10 14:24 -0400
      Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Mikko <mikko.levanto@iki.fi> - 2025-05-11 12:12 +0300
        Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED olcott <polcott333@gmail.com> - 2025-05-11 11:03 -0500
          Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED dbush <dbush.mobile@gmail.com> - 2025-05-11 12:05 -0400
            Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-11 15:19 -0700
          Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Richard Damon <richard@damon-family.org> - 2025-05-11 16:09 -0400
          Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Mikko <mikko.levanto@iki.fi> - 2025-05-12 10:45 +0300
            Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED olcott <polcott333@gmail.com> - 2025-05-12 09:47 -0500
              Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED dbush <dbush.mobile@gmail.com> - 2025-05-12 10:53 -0400
                Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED olcott <polcott333@gmail.com> - 2025-05-12 11:24 -0500
                  Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED dbush <dbush.mobile@gmail.com> - 2025-05-12 12:42 -0400
                    Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED olcott <polcott333@gmail.com> - 2025-05-12 11:59 -0500
                      Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED dbush <dbush.mobile@gmail.com> - 2025-05-12 13:08 -0400
                        Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED olcott <polcott333@gmail.com> - 2025-05-12 12:19 -0500
                          Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED dbush <dbush.mobile@gmail.com> - 2025-05-12 13:31 -0400
                          Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Mikko <mikko.levanto@iki.fi> - 2025-05-13 12:13 +0300
                  Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Richard Damon <richard@damon-family.org> - 2025-05-12 22:18 -0400
              Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Richard Damon <richard@damon-family.org> - 2025-05-12 22:15 -0400
              Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED Mikko <mikko.levanto@iki.fi> - 2025-05-13 12:10 +0300

Page 1 of 2  [1] 2  Next page →

#118280 — Re: Why I need to cross-post to comp.lang.c

On 2025-05-09 03:01:40 +0000, olcott said:

> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>> Richard Damon <richard@damon-family.org> writes:
>>> On 5/8/25 7:53 PM, olcott wrote:
>> [...]
>>>> void DDD()
>>>> {
>>>>   HHH(DDD);
>>>>   return;
>>>> }
>>>> We don't need to look at any of my code for me
>>>> to totally prove my point. For example when
>>>> the above DDD is correctly simulated by HHH
>>>> this simulated DDD cannot possibly reach its own
>>>> "return" instruction.
>>> 
>>> And thus not correctly simulatd.
>>> 
>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>> 
>> Perhaps I've missed something.  I don't see anything in the above that
>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>> far more of olcott's posts than I have, so perhaps you can clarify.
>> 
>> If we assume that HHH correctly simulates DDD, then the above code is
>> equivalent to:
>> 
>> void DDD()
>> {
>> DDD();
>> return;
>> }
>> 
>> which is a trivial case of infinite recursion.  As far as I can tell,
>> assuming that DDD() is actually called at some point, neither the
>> outer execution of DDD nor the nested (simulated) execution of DDD
>> can reach the return statement.  Infinite recursion might either
>> cause a stack overflow and a probable program crash, or an unending
>> loop if the compiler implements tail call optimization.
>> 
>> I see no contradiction, just an uninteresting case of infinite
>> recursion, something that's well understood by anyone with a
>> reasonable level of programming experience.  (And it has nothing to
>> do with the halting problem as far as I can tell, though of course
>> olcott has discussed the halting problem elsewhere.)
>> 
>> Richard, what am I missing?
>> 
> *****
> Now you are seeing what I was talking about.
> Now you are seeing why I needed to cross post
> to comp.lang.c

What were you told in comp.lang.c that you were not told in comp.theory?

-- 
Mikko

[toc] | [next] | [standalone]

#118302

On 10/05/2025 08:15, Mikko wrote:
> On 2025-05-09 03:01:40 +0000, olcott said:

<snip>

>> Now you are seeing what I was talking about.
>> Now you are seeing why I needed to cross post
>> to comp.lang.c
> 
> What were you told in comp.lang.c that you were not told in 
> comp.theory?

The good folks in comp.lang.c don't have a lot of time for this 
guy these days.

But if they had the patience to take a long hard look at his 
code, they would tell him rather more than he cares to know about 
just how broken it is.

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

#118313

On 5/10/25 6:10 AM, Richard Heathfield wrote:
> On 10/05/2025 08:15, Mikko wrote:
>> On 2025-05-09 03:01:40 +0000, olcott said:
> 
> <snip>
> 
>>> Now you are seeing what I was talking about.
>>> Now you are seeing why I needed to cross post
>>> to comp.lang.c
>>
>> What were you told in comp.lang.c that you were not told in comp.theory?
> 
> The good folks in comp.lang.c don't have a lot of time for this guy 
> these days.
> 
> But if they had the patience to take a long hard look at his code, they 
> would tell him rather more than he cares to know about just how broken 
> it is.
> 

It has already been pointed out that his code just violates what he says 
about it. It fundamentally can not be made into a "Pure Function" 
without major changes as it looks into global memory for a value 
initialized by the run time to determine if it is the "outer" version of 
the decider, or an inner version supposedly being simulated by it.

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

#118333 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/10/2025 2:15 AM, Mikko wrote:
> On 2025-05-09 03:01:40 +0000, olcott said:
> 
>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>> Richard Damon <richard@damon-family.org> writes:
>>>> On 5/8/25 7:53 PM, olcott wrote:
>>> [...]
>>>>> void DDD()
>>>>> {
>>>>>   HHH(DDD);
>>>>>   return;
>>>>> }
>>>>> We don't need to look at any of my code for me
>>>>> to totally prove my point. For example when
>>>>> the above DDD is correctly simulated by HHH
>>>>> this simulated DDD cannot possibly reach its own
>>>>> "return" instruction.
>>>>
>>>> And thus not correctly simulatd.
>>>>
>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>
>>> Perhaps I've missed something.  I don't see anything in the above that
>>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>
>>> If we assume that HHH correctly simulates DDD, then the above code is
>>> equivalent to:
>>>
>>> void DDD()
>>> {
>>> DDD();
>>> return;
>>> }
>>>
>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>> assuming that DDD() is actually called at some point, neither the
>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>> can reach the return statement.  Infinite recursion might either
>>> cause a stack overflow and a probable program crash, or an unending
>>> loop if the compiler implements tail call optimization.
>>>
>>> I see no contradiction, just an uninteresting case of infinite
>>> recursion, something that's well understood by anyone with a
>>> reasonable level of programming experience.  (And it has nothing to
>>> do with the halting problem as far as I can tell, though of course
>>> olcott has discussed the halting problem elsewhere.)
>>>
>>> Richard, what am I missing?
>>>
>> *****
>> Now you are seeing what I was talking about.
>> Now you are seeing why I needed to cross post
>> to comp.lang.c
> 
> What were you told in comp.lang.c that you were not told in comp.theory?
> 

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

People quickly realize that when DDD is correctly
simulated by HHH that DDD cannot possibly reach
its "return" statement (final halt state).

Once you know this then you can see that the
same thing applies to DD.

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

Once you know this then you know that the halting
problem's otherwise "impossible" input is non-halting.

Once you know this then you know that the halting
problem proof has been correctly refuted.

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

#118341 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On Sat, 2025-05-10 at 10:13 -0500, olcott wrote:
> On 5/10/2025 2:15 AM, Mikko wrote:
> > On 2025-05-09 03:01:40 +0000, olcott said:
> > 
> > > On 5/8/2025 9:23 PM, Keith Thompson wrote:
> > > > Richard Damon <richard@damon-family.org> writes:
> > > > > On 5/8/25 7:53 PM, olcott wrote:
> > > > [...]
> > > > > > void DDD()
> > > > > > {
> > > > > >   HHH(DDD);
> > > > > >   return;
> > > > > > }
> > > > > > We don't need to look at any of my code for me
> > > > > > to totally prove my point. For example when
> > > > > > the above DDD is correctly simulated by HHH
> > > > > > this simulated DDD cannot possibly reach its own
> > > > > > "return" instruction.
> > > > > 
> > > > > And thus not correctly simulatd.
> > > > > 
> > > > > Sorry, there is no "OS Exemption" to correct simulaiton;.
> > > > 
> > > > Perhaps I've missed something.  I don't see anything in the above that
> > > > implies that HHH does not correctly simulate DDD.  Richard, you've read
> > > > far more of olcott's posts than I have, so perhaps you can clarify.
> > > > 
> > > > If we assume that HHH correctly simulates DDD, then the above code is
> > > > equivalent to:
> > > > 
> > > > void DDD()
> > > > {
> > > > DDD();
> > > > return;
> > > > }
> > > > 
> > > > which is a trivial case of infinite recursion.  As far as I can tell,
> > > > assuming that DDD() is actually called at some point, neither the
> > > > outer execution of DDD nor the nested (simulated) execution of DDD
> > > > can reach the return statement.  Infinite recursion might either
> > > > cause a stack overflow and a probable program crash, or an unending
> > > > loop if the compiler implements tail call optimization.
> > > > 
> > > > I see no contradiction, just an uninteresting case of infinite
> > > > recursion, something that's well understood by anyone with a
> > > > reasonable level of programming experience.  (And it has nothing to
> > > > do with the halting problem as far as I can tell, though of course
> > > > olcott has discussed the halting problem elsewhere.)
> > > > 
> > > > Richard, what am I missing?
> > > > 
> > > *****
> > > Now you are seeing what I was talking about.
> > > Now you are seeing why I needed to cross post
> > > to comp.lang.c
> > 
> > What were you told in comp.lang.c that you were not told in comp.theory?
> > 
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> People quickly realize that when DDD is correctly
> simulated by HHH that DDD cannot possibly reach
> its "return" statement (final halt state).
> 
> Once you know this then you can see that the
> same thing applies to DD.
> 
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> Once you know this then you know that the halting
> problem's otherwise "impossible" input is non-halting.
> 
> Once you know this then you know that the halting
> problem proof has been correctly refuted.

Nope.
POOH is (at most) about whether the input D is "impossible" input or not.

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

#118345 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

Op 10.mei.2025 om 17:13 schreef olcott:
> On 5/10/2025 2:15 AM, Mikko wrote:
>> On 2025-05-09 03:01:40 +0000, olcott said:
>>
>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>> Richard Damon <richard@damon-family.org> writes:
>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>> [...]
>>>>>> void DDD()
>>>>>> {
>>>>>>   HHH(DDD);
>>>>>>   return;
>>>>>> }
>>>>>> We don't need to look at any of my code for me
>>>>>> to totally prove my point. For example when
>>>>>> the above DDD is correctly simulated by HHH
>>>>>> this simulated DDD cannot possibly reach its own
>>>>>> "return" instruction.
>>>>>
>>>>> And thus not correctly simulatd.
>>>>>
>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>
>>>> Perhaps I've missed something.  I don't see anything in the above that
>>>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>
>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>> equivalent to:
>>>>
>>>> void DDD()
>>>> {
>>>> DDD();
>>>> return;
>>>> }
>>>>
>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>> assuming that DDD() is actually called at some point, neither the
>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>> can reach the return statement.  Infinite recursion might either
>>>> cause a stack overflow and a probable program crash, or an unending
>>>> loop if the compiler implements tail call optimization.
>>>>
>>>> I see no contradiction, just an uninteresting case of infinite
>>>> recursion, something that's well understood by anyone with a
>>>> reasonable level of programming experience.  (And it has nothing to
>>>> do with the halting problem as far as I can tell, though of course
>>>> olcott has discussed the halting problem elsewhere.)
>>>>
>>>> Richard, what am I missing?
>>>>
>>> *****
>>> Now you are seeing what I was talking about.
>>> Now you are seeing why I needed to cross post
>>> to comp.lang.c
>>
>> What were you told in comp.lang.c that you were not told in comp.theory?
>>
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> People quickly realize that when DDD is correctly
> simulated by HHH that DDD cannot possibly reach
> its "return" statement (final halt state).
> 
> Once you know this then you can see that the
> same thing applies to DD.
> 
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> Once you know this then you know that the halting
> problem's otherwise "impossible" input is non-halting.
> 
> Once you know this then you know that the halting
> problem proof has been correctly refuted.
> 


Your memory seems bad. You said this before and it was shown to be 
irrelevant.
HHH does not correctly simulate DDD, because it halts the simulation 
before its gets to the most important part of the input, where it 
specifies a conditional abort. This bug makes that HHH misses the fact 
that this input specifies a buggy halting program and that it does not 
reach the reachable end of the simulation.
IT seems that you forget all easily verifiable facts when they disturb 
your dreams.

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

#118377 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/10/25 11:13 AM, olcott wrote:
> On 5/10/2025 2:15 AM, Mikko wrote:
>> On 2025-05-09 03:01:40 +0000, olcott said:
>>
>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>> Richard Damon <richard@damon-family.org> writes:
>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>> [...]
>>>>>> void DDD()
>>>>>> {
>>>>>>   HHH(DDD);
>>>>>>   return;
>>>>>> }
>>>>>> We don't need to look at any of my code for me
>>>>>> to totally prove my point. For example when
>>>>>> the above DDD is correctly simulated by HHH
>>>>>> this simulated DDD cannot possibly reach its own
>>>>>> "return" instruction.
>>>>>
>>>>> And thus not correctly simulatd.
>>>>>
>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>
>>>> Perhaps I've missed something.  I don't see anything in the above that
>>>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>
>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>> equivalent to:
>>>>
>>>> void DDD()
>>>> {
>>>> DDD();
>>>> return;
>>>> }
>>>>
>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>> assuming that DDD() is actually called at some point, neither the
>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>> can reach the return statement.  Infinite recursion might either
>>>> cause a stack overflow and a probable program crash, or an unending
>>>> loop if the compiler implements tail call optimization.
>>>>
>>>> I see no contradiction, just an uninteresting case of infinite
>>>> recursion, something that's well understood by anyone with a
>>>> reasonable level of programming experience.  (And it has nothing to
>>>> do with the halting problem as far as I can tell, though of course
>>>> olcott has discussed the halting problem elsewhere.)
>>>>
>>>> Richard, what am I missing?
>>>>
>>> *****
>>> Now you are seeing what I was talking about.
>>> Now you are seeing why I needed to cross post
>>> to comp.lang.c
>>
>> What were you told in comp.lang.c that you were not told in comp.theory?
>>
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> People quickly realize that when DDD is correctly
> simulated by HHH that DDD cannot possibly reach
> its "return" statement (final halt state).

But you are just showing your stupidity, as your DDD is IMPOSSIBLE to 
correcctly emulate, as what you define as the repesentation of DDD, amd 
your own descirption of it, excludes the code for HHH, so you can not 
use that, and thus it just doesn't HAVE behavior beyond the call 
instruction, is it just isn't a program to HAVE behavior.

Until you actually define that HHH has been added as part of the DDD in 
the input to make it actually be a program, it just can not be 
"correctly emulated"

Of course, once you do that, every different pairing of DDD to an HHH is 
a different input, and thus none of your HHH's are paired to the same 
DDD, so you can't translate behavior from one DDD/HHH pair to another.

> 
> Once you know this then you can see that the
> same thing applies to DD.

Right, it isn't a program either, not until you ADD the code of HHH to 
it, and thus each HHH gets a different DD/HHH pairing,

> 
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> Once you know this then you know that the halting
> problem's otherwise "impossible" input is non-halting.

Nope. Just that you are showing yourself to be non-thinking.
Your HHH can not correctly emulate an input that is not actualy the 
representation of a program.

> 
> Once you know this then you know that the halting
> problem proof has been correctly refuted.
> 

Nope, just that you have proved yourself to be a liar.

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

#118448 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 2025-05-10 15:13:32 +0000, olcott said:

> On 5/10/2025 2:15 AM, Mikko wrote:
>> On 2025-05-09 03:01:40 +0000, olcott said:
>> 
>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>> Richard Damon <richard@damon-family.org> writes:
>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>> [...]
>>>>>> void DDD()
>>>>>> {
>>>>>>   HHH(DDD);
>>>>>>   return;
>>>>>> }
>>>>>> We don't need to look at any of my code for me
>>>>>> to totally prove my point. For example when
>>>>>> the above DDD is correctly simulated by HHH
>>>>>> this simulated DDD cannot possibly reach its own
>>>>>> "return" instruction.
>>>>> 
>>>>> And thus not correctly simulatd.
>>>>> 
>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>> 
>>>> Perhaps I've missed something.  I don't see anything in the above that
>>>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>> 
>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>> equivalent to:
>>>> 
>>>> void DDD()
>>>> {
>>>> DDD();
>>>> return;
>>>> }
>>>> 
>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>> assuming that DDD() is actually called at some point, neither the
>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>> can reach the return statement.  Infinite recursion might either
>>>> cause a stack overflow and a probable program crash, or an unending
>>>> loop if the compiler implements tail call optimization.
>>>> 
>>>> I see no contradiction, just an uninteresting case of infinite
>>>> recursion, something that's well understood by anyone with a
>>>> reasonable level of programming experience.  (And it has nothing to
>>>> do with the halting problem as far as I can tell, though of course
>>>> olcott has discussed the halting problem elsewhere.)
>>>> 
>>>> Richard, what am I missing?
>>>> 
>>> *****
>>> Now you are seeing what I was talking about.
>>> Now you are seeing why I needed to cross post
>>> to comp.lang.c
>> 
>> What were you told in comp.lang.c that you were not told in comp.theory?
> 
> void DDD()
> {
>    HHH(DDD);
>    return;
> }
> 
> People quickly realize that when DDD is correctly
> simulated by HHH that DDD cannot possibly reach
> its "return" statement (final halt state).
> 
> Once you know this then you can see that the
> same thing applies to DD.
> 
> int DD()
> {
>    int Halt_Status = HHH(DD);
>    if (Halt_Status)
>      HERE: goto HERE;
>    return Halt_Status;
> }
> 
> Once you know this then you know that the halting
> problem's otherwise "impossible" input is non-halting.
> 
> Once you know this then you know that the halting
> problem proof has been correctly refuted.

You are lying again. Nothing above was told you in comp.lang.c.

-- 
Mikko

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

#118498 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/11/2025 4:12 AM, Mikko wrote:
> On 2025-05-10 15:13:32 +0000, olcott said:
> 
>> On 5/10/2025 2:15 AM, Mikko wrote:
>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>
>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>> [...]
>>>>>>> void DDD()
>>>>>>> {
>>>>>>>   HHH(DDD);
>>>>>>>   return;
>>>>>>> }
>>>>>>> We don't need to look at any of my code for me
>>>>>>> to totally prove my point. For example when
>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>> "return" instruction.
>>>>>>
>>>>>> And thus not correctly simulatd.
>>>>>>
>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>
>>>>> Perhaps I've missed something.  I don't see anything in the above that
>>>>> implies that HHH does not correctly simulate DDD.  Richard, you've 
>>>>> read
>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>
>>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>>> equivalent to:
>>>>>
>>>>> void DDD()
>>>>> {
>>>>> DDD();
>>>>> return;
>>>>> }
>>>>>
>>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>>> assuming that DDD() is actually called at some point, neither the
>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>> can reach the return statement.  Infinite recursion might either
>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>> loop if the compiler implements tail call optimization.
>>>>>
>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>> recursion, something that's well understood by anyone with a
>>>>> reasonable level of programming experience.  (And it has nothing to
>>>>> do with the halting problem as far as I can tell, though of course
>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>
>>>>> Richard, what am I missing?
>>>>>
>>>> *****
>>>> Now you are seeing what I was talking about.
>>>> Now you are seeing why I needed to cross post
>>>> to comp.lang.c
>>>
>>> What were you told in comp.lang.c that you were not told in comp.theory?
>>
>> void DDD()
>> {
>>    HHH(DDD);
>>    return;
>> }
>>
>> People quickly realize that when DDD is correctly
>> simulated by HHH that DDD cannot possibly reach
>> its "return" statement (final halt state).
>>
>> Once you know this then you can see that the
>> same thing applies to DD.
>>
>> int DD()
>> {
>>    int Halt_Status = HHH(DD);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> Once you know this then you know that the halting
>> problem's otherwise "impossible" input is non-halting.
>>
>> Once you know this then you know that the halting
>> problem proof has been correctly refuted.
> 
> You are lying again. Nothing above was told you in comp.lang.c.
> 

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

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

#118501 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/11/2025 12:03 PM, olcott wrote:
> On 5/11/2025 4:12 AM, Mikko wrote:
>> On 2025-05-10 15:13:32 +0000, olcott said:
>>
>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>
>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>> [...]
>>>>>>>> void DDD()
>>>>>>>> {
>>>>>>>>   HHH(DDD);
>>>>>>>>   return;
>>>>>>>> }
>>>>>>>> We don't need to look at any of my code for me
>>>>>>>> to totally prove my point. For example when
>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>> "return" instruction.
>>>>>>>
>>>>>>> And thus not correctly simulatd.
>>>>>>>
>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>
>>>>>> Perhaps I've missed something.  I don't see anything in the above 
>>>>>> that
>>>>>> implies that HHH does not correctly simulate DDD.  Richard, you've 
>>>>>> read
>>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>>
>>>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>>>> equivalent to:
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>> DDD();
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>>> loop if the compiler implements tail call optimization.
>>>>>>
>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>> recursion, something that's well understood by anyone with a
>>>>>> reasonable level of programming experience.  (And it has nothing to
>>>>>> do with the halting problem as far as I can tell, though of course
>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>
>>>>>> Richard, what am I missing?
>>>>>>
>>>>> *****
>>>>> Now you are seeing what I was talking about.
>>>>> Now you are seeing why I needed to cross post
>>>>> to comp.lang.c
>>>>
>>>> What were you told in comp.lang.c that you were not told in 
>>>> comp.theory?
>>>
>>> void DDD()
>>> {
>>>    HHH(DDD);
>>>    return;
>>> }
>>>
>>> People quickly realize that when DDD is correctly
>>> simulated by HHH that DDD cannot possibly reach
>>> its "return" statement (final halt state).
>>>
>>> Once you know this then you can see that the
>>> same thing applies to DD.
>>>
>>> int DD()
>>> {
>>>    int Halt_Status = HHH(DD);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> Once you know this then you know that the halting
>>> problem's otherwise "impossible" input is non-halting.
>>>
>>> Once you know this then you know that the halting
>>> problem proof has been correctly refuted.
>>
>> You are lying again. Nothing above was told you in comp.lang.c.
>>
> 
> 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.
>  >
> 

But:

On 5/9/2025 12:11 AM, Keith Thompson wrote:
 > Do not overestimate what I've agreed to.  I must still consider the
 > possibility that I've been led into a logical trap of some sort,
 > and that I've missed some subtle flaw.
 > ...
 > Now you're talking about simulating "1 or more instructions"
 > of DD.  I thought that HHH was supposed to "accurately simulate"
 > the function whose argument is passed to it.  Emulating just "1 or
 > more instructions" is not accurate simulation.

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

#118575 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

dbush <dbush.mobile@gmail.com> writes:
> On 5/11/2025 12:03 PM, olcott wrote:
>> On 5/11/2025 4:12 AM, Mikko wrote:
[...]
>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>
>> On 5/8/2025 8:30 PM, Keith Thompson wrote:
[SNIP]
> But:
>
> On 5/9/2025 12:11 AM, Keith Thompson wrote:
>> Do not overestimate what I've agreed to.
[SNIP]

One thing that's been missed (deliberately or not) is that I did
not reply to olcott in comp.lang.c.  Some time ago, I configured
my newsreader so that it never shows me anything olcott posts or
cross-posts in comp.lang.c.

I've recently replied to some of his articles here in comp.theory.

If olcott claims that his posting to comp.lang.c has had the effect
of bringing me into the discussion, he is wrong.  I read both
newsgroups.  (I offer no opinion on whether he's deliberately lying.)

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */

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

#118559 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/11/25 12:03 PM, olcott wrote:
> On 5/11/2025 4:12 AM, Mikko wrote:
>> On 2025-05-10 15:13:32 +0000, olcott said:
>>
>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>
>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>> [...]
>>>>>>>> void DDD()
>>>>>>>> {
>>>>>>>>   HHH(DDD);
>>>>>>>>   return;
>>>>>>>> }
>>>>>>>> We don't need to look at any of my code for me
>>>>>>>> to totally prove my point. For example when
>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>> "return" instruction.
>>>>>>>
>>>>>>> And thus not correctly simulatd.
>>>>>>>
>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>
>>>>>> Perhaps I've missed something.  I don't see anything in the above 
>>>>>> that
>>>>>> implies that HHH does not correctly simulate DDD.  Richard, you've 
>>>>>> read
>>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>>
>>>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>>>> equivalent to:
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>> DDD();
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>>> loop if the compiler implements tail call optimization.
>>>>>>
>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>> recursion, something that's well understood by anyone with a
>>>>>> reasonable level of programming experience.  (And it has nothing to
>>>>>> do with the halting problem as far as I can tell, though of course
>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>
>>>>>> Richard, what am I missing?
>>>>>>
>>>>> *****
>>>>> Now you are seeing what I was talking about.
>>>>> Now you are seeing why I needed to cross post
>>>>> to comp.lang.c
>>>>
>>>> What were you told in comp.lang.c that you were not told in 
>>>> comp.theory?
>>>
>>> void DDD()
>>> {
>>>    HHH(DDD);
>>>    return;
>>> }
>>>
>>> People quickly realize that when DDD is correctly
>>> simulated by HHH that DDD cannot possibly reach
>>> its "return" statement (final halt state).
>>>
>>> Once you know this then you can see that the
>>> same thing applies to DD.
>>>
>>> int DD()
>>> {
>>>    int Halt_Status = HHH(DD);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> Once you know this then you know that the halting
>>> problem's otherwise "impossible" input is non-halting.
>>>
>>> Once you know this then you know that the halting
>>> problem proof has been correctly refuted.
>>
>> You are lying again. Nothing above was told you in comp.lang.c.
>>
> 
> 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.
>  >
> 

Right, if HHH is a correct emulator, and thus not a decideer, then DDD 
is non-halting.

Of course, the definition of DDD includes the HHH that it calls, so 
changing HHH to be the one that is a decider and not a correct simulator 
means we have a different DDD, and thus you can't apply that result.

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

#118658 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 2025-05-11 16:03:29 +0000, olcott said:

> On 5/11/2025 4:12 AM, Mikko wrote:
>> On 2025-05-10 15:13:32 +0000, olcott said:
>> 
>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>> 
>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>> [...]
>>>>>>>> void DDD()
>>>>>>>> {
>>>>>>>>   HHH(DDD);
>>>>>>>>   return;
>>>>>>>> }
>>>>>>>> We don't need to look at any of my code for me
>>>>>>>> to totally prove my point. For example when
>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>> "return" instruction.
>>>>>>> 
>>>>>>> And thus not correctly simulatd.
>>>>>>> 
>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>> 
>>>>>> Perhaps I've missed something.  I don't see anything in the above that
>>>>>> implies that HHH does not correctly simulate DDD.  Richard, you've read
>>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>> 
>>>>>> If we assume that HHH correctly simulates DDD, then the above code is
>>>>>> equivalent to:
>>>>>> 
>>>>>> void DDD()
>>>>>> {
>>>>>> DDD();
>>>>>> return;
>>>>>> }
>>>>>> 
>>>>>> which is a trivial case of infinite recursion.  As far as I can tell,
>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>>> loop if the compiler implements tail call optimization.
>>>>>> 
>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>> recursion, something that's well understood by anyone with a
>>>>>> reasonable level of programming experience.  (And it has nothing to
>>>>>> do with the halting problem as far as I can tell, though of course
>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>> 
>>>>>> Richard, what am I missing?
>>>>>> 
>>>>> *****
>>>>> Now you are seeing what I was talking about.
>>>>> Now you are seeing why I needed to cross post
>>>>> to comp.lang.c
>>>> 
>>>> What were you told in comp.lang.c that you were not told in comp.theory?
>>> 
>>> void DDD()
>>> {
>>>    HHH(DDD);
>>>    return;
>>> }
>>> 
>>> People quickly realize that when DDD is correctly
>>> simulated by HHH that DDD cannot possibly reach
>>> its "return" statement (final halt state).
>>> 
>>> Once you know this then you can see that the
>>> same thing applies to DD.
>>> 
>>> int DD()
>>> {
>>>    int Halt_Status = HHH(DD);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>> 
>>> Once you know this then you know that the halting
>>> problem's otherwise "impossible" input is non-halting.
>>> 
>>> Once you know this then you know that the halting
>>> problem proof has been correctly refuted.
>> 
>> You are lying again. Nothing above was told you in comp.lang.c.
> 
> 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.
>  >

What he says is true. However, the assumptions that HHH does a correct
simulation and that it does nothing else are not.

-- 
Mikko

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

#118676 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 2:45 AM, Mikko wrote:
> On 2025-05-11 16:03:29 +0000, olcott said:
> 
>> On 5/11/2025 4:12 AM, Mikko wrote:
>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>
>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>
>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>> [...]
>>>>>>>>> void DDD()
>>>>>>>>> {
>>>>>>>>>   HHH(DDD);
>>>>>>>>>   return;
>>>>>>>>> }
>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>> to totally prove my point. For example when
>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>> "return" instruction.
>>>>>>>>
>>>>>>>> And thus not correctly simulatd.
>>>>>>>>
>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>
>>>>>>> Perhaps I've missed something.  I don't see anything in the above 
>>>>>>> that
>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>> you've read
>>>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>>>
>>>>>>> If we assume that HHH correctly simulates DDD, then the above 
>>>>>>> code is
>>>>>>> equivalent to:
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>> DDD();
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> which is a trivial case of infinite recursion.  As far as I can 
>>>>>>> tell,
>>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>
>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>> reasonable level of programming experience.  (And it has nothing to
>>>>>>> do with the halting problem as far as I can tell, though of course
>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>
>>>>>>> Richard, what am I missing?
>>>>>>>
>>>>>> *****
>>>>>> Now you are seeing what I was talking about.
>>>>>> Now you are seeing why I needed to cross post
>>>>>> to comp.lang.c
>>>>>
>>>>> What were you told in comp.lang.c that you were not told in 
>>>>> comp.theory?
>>>>
>>>> void DDD()
>>>> {
>>>>    HHH(DDD);
>>>>    return;
>>>> }
>>>>
>>>> People quickly realize that when DDD is correctly
>>>> simulated by HHH that DDD cannot possibly reach
>>>> its "return" statement (final halt state).
>>>>
>>>> Once you know this then you can see that the
>>>> same thing applies to DD.
>>>>
>>>> int DD()
>>>> {
>>>>    int Halt_Status = HHH(DD);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> Once you know this then you know that the halting
>>>> problem's otherwise "impossible" input is non-halting.
>>>>
>>>> Once you know this then you know that the halting
>>>> problem proof has been correctly refuted.
>>>
>>> You are lying again. Nothing above was told you in comp.lang.c.
>>
>> 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.
>>  >
> 
> What he says is true. However, the assumptions that HHH does a correct
> simulation and that it does nothing else are not.
> 

_DDD()
[00002172] 55         push ebp      ; housekeeping
[00002173] 8bec       mov ebp,esp   ; housekeeping
[00002175] 6872210000 push 00002172 ; push DDD
[0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
[0000217f] 83c404     add esp,+04
[00002182] 5d         pop ebp
[00002183] c3         ret
Size in bytes:(0018) [00002183]

We make an infinite set of purely hypothetical HHH pure
x86 emulators each one is at machine address 000015d2
thus called by DDD.

The first HHH emulates one step the Nth HHH emulates N steps.
No DDD of any HHH/DDD pair every reaches its own "ret"
instruction final halt state.

Since every DDD element of every every HHH/DDD
pair fails to halt therefore every HHH would be
correct to reject its input as non-halting.

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

#118677 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 10:47 AM, olcott wrote:
> On 5/12/2025 2:45 AM, Mikko wrote:
>> On 2025-05-11 16:03:29 +0000, olcott said:
>>
>>> On 5/11/2025 4:12 AM, Mikko wrote:
>>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>>
>>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>>
>>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>>> [...]
>>>>>>>>>> void DDD()
>>>>>>>>>> {
>>>>>>>>>>   HHH(DDD);
>>>>>>>>>>   return;
>>>>>>>>>> }
>>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>>> to totally prove my point. For example when
>>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>>> "return" instruction.
>>>>>>>>>
>>>>>>>>> And thus not correctly simulatd.
>>>>>>>>>
>>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>>
>>>>>>>> Perhaps I've missed something.  I don't see anything in the 
>>>>>>>> above that
>>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>>> you've read
>>>>>>>> far more of olcott's posts than I have, so perhaps you can clarify.
>>>>>>>>
>>>>>>>> If we assume that HHH correctly simulates DDD, then the above 
>>>>>>>> code is
>>>>>>>> equivalent to:
>>>>>>>>
>>>>>>>> void DDD()
>>>>>>>> {
>>>>>>>> DDD();
>>>>>>>> return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> which is a trivial case of infinite recursion.  As far as I can 
>>>>>>>> tell,
>>>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>>>> cause a stack overflow and a probable program crash, or an unending
>>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>>
>>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>>> reasonable level of programming experience.  (And it has nothing to
>>>>>>>> do with the halting problem as far as I can tell, though of course
>>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>>
>>>>>>>> Richard, what am I missing?
>>>>>>>>
>>>>>>> *****
>>>>>>> Now you are seeing what I was talking about.
>>>>>>> Now you are seeing why I needed to cross post
>>>>>>> to comp.lang.c
>>>>>>
>>>>>> What were you told in comp.lang.c that you were not told in 
>>>>>> comp.theory?
>>>>>
>>>>> void DDD()
>>>>> {
>>>>>    HHH(DDD);
>>>>>    return;
>>>>> }
>>>>>
>>>>> People quickly realize that when DDD is correctly
>>>>> simulated by HHH that DDD cannot possibly reach
>>>>> its "return" statement (final halt state).
>>>>>
>>>>> Once you know this then you can see that the
>>>>> same thing applies to DD.
>>>>>
>>>>> int DD()
>>>>> {
>>>>>    int Halt_Status = HHH(DD);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> Once you know this then you know that the halting
>>>>> problem's otherwise "impossible" input is non-halting.
>>>>>
>>>>> Once you know this then you know that the halting
>>>>> problem proof has been correctly refuted.
>>>>
>>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>
>>> 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.
>>>  >
>>
>> What he says is true. However, the assumptions that HHH does a correct
>> simulation and that it does nothing else are not.
>>
> 
> _DDD()
> [00002172] 55         push ebp      ; housekeeping
> [00002173] 8bec       mov ebp,esp   ; housekeeping
> [00002175] 6872210000 push 00002172 ; push DDD
> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
> [0000217f] 83c404     add esp,+04
> [00002182] 5d         pop ebp
> [00002183] c3         ret
> Size in bytes:(0018) [00002183]
> 
> We make an infinite set of purely hypothetical HHH pure
> x86 emulators each one is at machine address 000015d2
> thus called by DDD.

And each DDD is a distinct algorithm.

Changing the input is not allowed.

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

#118699 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 9:53 AM, dbush wrote:
> On 5/12/2025 10:47 AM, olcott wrote:
>> On 5/12/2025 2:45 AM, Mikko wrote:
>>> On 2025-05-11 16:03:29 +0000, olcott said:
>>>
>>>> On 5/11/2025 4:12 AM, Mikko wrote:
>>>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>>>
>>>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>>>
>>>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>>>> [...]
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>>   HHH(DDD);
>>>>>>>>>>>   return;
>>>>>>>>>>> }
>>>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>>>> to totally prove my point. For example when
>>>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>>>> "return" instruction.
>>>>>>>>>>
>>>>>>>>>> And thus not correctly simulatd.
>>>>>>>>>>
>>>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>>>
>>>>>>>>> Perhaps I've missed something.  I don't see anything in the 
>>>>>>>>> above that
>>>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>>>> you've read
>>>>>>>>> far more of olcott's posts than I have, so perhaps you can 
>>>>>>>>> clarify.
>>>>>>>>>
>>>>>>>>> If we assume that HHH correctly simulates DDD, then the above 
>>>>>>>>> code is
>>>>>>>>> equivalent to:
>>>>>>>>>
>>>>>>>>> void DDD()
>>>>>>>>> {
>>>>>>>>> DDD();
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> which is a trivial case of infinite recursion.  As far as I can 
>>>>>>>>> tell,
>>>>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>>>>> outer execution of DDD nor the nested (simulated) execution of DDD
>>>>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>>>>> cause a stack overflow and a probable program crash, or an 
>>>>>>>>> unending
>>>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>>>
>>>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>>>> reasonable level of programming experience.  (And it has 
>>>>>>>>> nothing to
>>>>>>>>> do with the halting problem as far as I can tell, though of course
>>>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>>>
>>>>>>>>> Richard, what am I missing?
>>>>>>>>>
>>>>>>>> *****
>>>>>>>> Now you are seeing what I was talking about.
>>>>>>>> Now you are seeing why I needed to cross post
>>>>>>>> to comp.lang.c
>>>>>>>
>>>>>>> What were you told in comp.lang.c that you were not told in 
>>>>>>> comp.theory?
>>>>>>
>>>>>> void DDD()
>>>>>> {
>>>>>>    HHH(DDD);
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> People quickly realize that when DDD is correctly
>>>>>> simulated by HHH that DDD cannot possibly reach
>>>>>> its "return" statement (final halt state).
>>>>>>
>>>>>> Once you know this then you can see that the
>>>>>> same thing applies to DD.
>>>>>>
>>>>>> int DD()
>>>>>> {
>>>>>>    int Halt_Status = HHH(DD);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> Once you know this then you know that the halting
>>>>>> problem's otherwise "impossible" input is non-halting.
>>>>>>
>>>>>> Once you know this then you know that the halting
>>>>>> problem proof has been correctly refuted.
>>>>>
>>>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>>
>>>> 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.
>>>>  >
>>>
>>> What he says is true. However, the assumptions that HHH does a correct
>>> simulation and that it does nothing else are not.
>>>
>>
>> _DDD()
>> [00002172] 55         push ebp      ; housekeeping
>> [00002173] 8bec       mov ebp,esp   ; housekeeping
>> [00002175] 6872210000 push 00002172 ; push DDD
>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
>> [0000217f] 83c404     add esp,+04
>> [00002182] 5d         pop ebp
>> [00002183] c3         ret
>> Size in bytes:(0018) [00002183]
>>
>> We make an infinite set of purely hypothetical HHH pure
>> x86 emulators each one is at machine address 000015d2
>> thus called by DDD.
> 
> And each DDD is a distinct algorithm.
> 

Such that none of them halt.
The only difference is the number of steps of DDD
emulated by HHH.

This proves that each element of the infinite
set of HHH/DDD pairs never halts. This proves
the the specific element of the encoded HHH
that emulates 7 steps of DDD is correct to reject
DDD as non-halting.

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

#118705 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 12:24 PM, olcott wrote:
> On 5/12/2025 9:53 AM, dbush wrote:
>> On 5/12/2025 10:47 AM, olcott wrote:
>>> On 5/12/2025 2:45 AM, Mikko wrote:
>>>> On 2025-05-11 16:03:29 +0000, olcott said:
>>>>
>>>>> On 5/11/2025 4:12 AM, Mikko wrote:
>>>>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>>>>
>>>>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>>>>> [...]
>>>>>>>>>>>> void DDD()
>>>>>>>>>>>> {
>>>>>>>>>>>>   HHH(DDD);
>>>>>>>>>>>>   return;
>>>>>>>>>>>> }
>>>>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>>>>> to totally prove my point. For example when
>>>>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>>>>> "return" instruction.
>>>>>>>>>>>
>>>>>>>>>>> And thus not correctly simulatd.
>>>>>>>>>>>
>>>>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>>>>
>>>>>>>>>> Perhaps I've missed something.  I don't see anything in the 
>>>>>>>>>> above that
>>>>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>>>>> you've read
>>>>>>>>>> far more of olcott's posts than I have, so perhaps you can 
>>>>>>>>>> clarify.
>>>>>>>>>>
>>>>>>>>>> If we assume that HHH correctly simulates DDD, then the above 
>>>>>>>>>> code is
>>>>>>>>>> equivalent to:
>>>>>>>>>>
>>>>>>>>>> void DDD()
>>>>>>>>>> {
>>>>>>>>>> DDD();
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> which is a trivial case of infinite recursion.  As far as I 
>>>>>>>>>> can tell,
>>>>>>>>>> assuming that DDD() is actually called at some point, neither the
>>>>>>>>>> outer execution of DDD nor the nested (simulated) execution of 
>>>>>>>>>> DDD
>>>>>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>>>>>> cause a stack overflow and a probable program crash, or an 
>>>>>>>>>> unending
>>>>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>>>>
>>>>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>>>>> reasonable level of programming experience.  (And it has 
>>>>>>>>>> nothing to
>>>>>>>>>> do with the halting problem as far as I can tell, though of 
>>>>>>>>>> course
>>>>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>>>>
>>>>>>>>>> Richard, what am I missing?
>>>>>>>>>>
>>>>>>>>> *****
>>>>>>>>> Now you are seeing what I was talking about.
>>>>>>>>> Now you are seeing why I needed to cross post
>>>>>>>>> to comp.lang.c
>>>>>>>>
>>>>>>>> What were you told in comp.lang.c that you were not told in 
>>>>>>>> comp.theory?
>>>>>>>
>>>>>>> void DDD()
>>>>>>> {
>>>>>>>    HHH(DDD);
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> People quickly realize that when DDD is correctly
>>>>>>> simulated by HHH that DDD cannot possibly reach
>>>>>>> its "return" statement (final halt state).
>>>>>>>
>>>>>>> Once you know this then you can see that the
>>>>>>> same thing applies to DD.
>>>>>>>
>>>>>>> int DD()
>>>>>>> {
>>>>>>>    int Halt_Status = HHH(DD);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> Once you know this then you know that the halting
>>>>>>> problem's otherwise "impossible" input is non-halting.
>>>>>>>
>>>>>>> Once you know this then you know that the halting
>>>>>>> problem proof has been correctly refuted.
>>>>>>
>>>>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>>>
>>>>> 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.
>>>>>  >
>>>>
>>>> What he says is true. However, the assumptions that HHH does a correct
>>>> simulation and that it does nothing else are not.
>>>>
>>>
>>> _DDD()
>>> [00002172] 55         push ebp      ; housekeeping
>>> [00002173] 8bec       mov ebp,esp   ; housekeeping
>>> [00002175] 6872210000 push 00002172 ; push DDD
>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
>>> [0000217f] 83c404     add esp,+04
>>> [00002182] 5d         pop ebp
>>> [00002183] c3         ret
>>> Size in bytes:(0018) [00002183]
>>>
>>> We make an infinite set of purely hypothetical HHH pure
>>> x86 emulators each one is at machine address 000015d2
>>> thus called by DDD.
>>
>> And each DDD is a distinct algorithm.
>>
> 
> Such that none of them halt.
> The only difference is the number of steps of DDD
> emulated by HHH.

And the halt status of algorithm DDD has nothing to do with the halt 
status of algorithm DDD1, DDD2, etc.

The only thing that matters is the behavior of algorithm DDD when 
executed directly, as per the requirements:


Given any algorithm (i.e. a fixed immutable sequence of instructions) X 
described as <X> with input Y:

A solution to the halting problem is an algorithm H that computes the 
following mapping:

(<X>,Y) maps to 1 if and only if X(Y) halts when executed directly
(<X>,Y) maps to 0 if and only if X(Y) does not halt when executed directly

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

#118712 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 11:42 AM, dbush wrote:
> On 5/12/2025 12:24 PM, olcott wrote:
>> On 5/12/2025 9:53 AM, dbush wrote:
>>> On 5/12/2025 10:47 AM, olcott wrote:
>>>> On 5/12/2025 2:45 AM, Mikko wrote:
>>>>> On 2025-05-11 16:03:29 +0000, olcott said:
>>>>>
>>>>>> On 5/11/2025 4:12 AM, Mikko wrote:
>>>>>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>>>>>
>>>>>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>>>>>> [...]
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>   HHH(DDD);
>>>>>>>>>>>>>   return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>>>>>> to totally prove my point. For example when
>>>>>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>>>>>> "return" instruction.
>>>>>>>>>>>>
>>>>>>>>>>>> And thus not correctly simulatd.
>>>>>>>>>>>>
>>>>>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>>>>>
>>>>>>>>>>> Perhaps I've missed something.  I don't see anything in the 
>>>>>>>>>>> above that
>>>>>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>>>>>> you've read
>>>>>>>>>>> far more of olcott's posts than I have, so perhaps you can 
>>>>>>>>>>> clarify.
>>>>>>>>>>>
>>>>>>>>>>> If we assume that HHH correctly simulates DDD, then the above 
>>>>>>>>>>> code is
>>>>>>>>>>> equivalent to:
>>>>>>>>>>>
>>>>>>>>>>> void DDD()
>>>>>>>>>>> {
>>>>>>>>>>> DDD();
>>>>>>>>>>> return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> which is a trivial case of infinite recursion.  As far as I 
>>>>>>>>>>> can tell,
>>>>>>>>>>> assuming that DDD() is actually called at some point, neither 
>>>>>>>>>>> the
>>>>>>>>>>> outer execution of DDD nor the nested (simulated) execution 
>>>>>>>>>>> of DDD
>>>>>>>>>>> can reach the return statement.  Infinite recursion might either
>>>>>>>>>>> cause a stack overflow and a probable program crash, or an 
>>>>>>>>>>> unending
>>>>>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>>>>>
>>>>>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>>>>>> reasonable level of programming experience.  (And it has 
>>>>>>>>>>> nothing to
>>>>>>>>>>> do with the halting problem as far as I can tell, though of 
>>>>>>>>>>> course
>>>>>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>>>>>
>>>>>>>>>>> Richard, what am I missing?
>>>>>>>>>>>
>>>>>>>>>> *****
>>>>>>>>>> Now you are seeing what I was talking about.
>>>>>>>>>> Now you are seeing why I needed to cross post
>>>>>>>>>> to comp.lang.c
>>>>>>>>>
>>>>>>>>> What were you told in comp.lang.c that you were not told in 
>>>>>>>>> comp.theory?
>>>>>>>>
>>>>>>>> void DDD()
>>>>>>>> {
>>>>>>>>    HHH(DDD);
>>>>>>>>    return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> People quickly realize that when DDD is correctly
>>>>>>>> simulated by HHH that DDD cannot possibly reach
>>>>>>>> its "return" statement (final halt state).
>>>>>>>>
>>>>>>>> Once you know this then you can see that the
>>>>>>>> same thing applies to DD.
>>>>>>>>
>>>>>>>> int DD()
>>>>>>>> {
>>>>>>>>    int Halt_Status = HHH(DD);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return Halt_Status;
>>>>>>>> }
>>>>>>>>
>>>>>>>> Once you know this then you know that the halting
>>>>>>>> problem's otherwise "impossible" input is non-halting.
>>>>>>>>
>>>>>>>> Once you know this then you know that the halting
>>>>>>>> problem proof has been correctly refuted.
>>>>>>>
>>>>>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>>>>
>>>>>> 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.
>>>>>>  >
>>>>>
>>>>> What he says is true. However, the assumptions that HHH does a correct
>>>>> simulation and that it does nothing else are not.
>>>>>
>>>>
>>>> _DDD()
>>>> [00002172] 55         push ebp      ; housekeeping
>>>> [00002173] 8bec       mov ebp,esp   ; housekeeping
>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
>>>> [0000217f] 83c404     add esp,+04
>>>> [00002182] 5d         pop ebp
>>>> [00002183] c3         ret
>>>> Size in bytes:(0018) [00002183]
>>>>
>>>> We make an infinite set of purely hypothetical HHH pure
>>>> x86 emulators each one is at machine address 000015d2
>>>> thus called by DDD.
>>>
>>> And each DDD is a distinct algorithm.
>>>
>>
>> Such that none of them halt.
>> The only difference is the number of steps of DDD
>> emulated by HHH.
> 
> And the halt status of algorithm DDD has nothing to do with the halt 
> status of algorithm DDD1, DDD2, etc.
> 

When the only difference between HHH/DDD pairs is that
each HHH emulates one more step than the prior one then
the fact that none of these DDD instances halts proves
that each instance also does not halt.

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

#118716 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 12:59 PM, olcott wrote:
> On 5/12/2025 11:42 AM, dbush wrote:
>> On 5/12/2025 12:24 PM, olcott wrote:
>>> On 5/12/2025 9:53 AM, dbush wrote:
>>>> On 5/12/2025 10:47 AM, olcott wrote:
>>>>> On 5/12/2025 2:45 AM, Mikko wrote:
>>>>>> On 2025-05-11 16:03:29 +0000, olcott said:
>>>>>>
>>>>>>> On 5/11/2025 4:12 AM, Mikko wrote:
>>>>>>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>>>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>>>>>>> [...]
>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>   HHH(DDD);
>>>>>>>>>>>>>>   return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>>>>>>> to totally prove my point. For example when
>>>>>>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>>>>>>> "return" instruction.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And thus not correctly simulatd.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>>>>>>
>>>>>>>>>>>> Perhaps I've missed something.  I don't see anything in the 
>>>>>>>>>>>> above that
>>>>>>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>>>>>>> you've read
>>>>>>>>>>>> far more of olcott's posts than I have, so perhaps you can 
>>>>>>>>>>>> clarify.
>>>>>>>>>>>>
>>>>>>>>>>>> If we assume that HHH correctly simulates DDD, then the 
>>>>>>>>>>>> above code is
>>>>>>>>>>>> equivalent to:
>>>>>>>>>>>>
>>>>>>>>>>>> void DDD()
>>>>>>>>>>>> {
>>>>>>>>>>>> DDD();
>>>>>>>>>>>> return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> which is a trivial case of infinite recursion.  As far as I 
>>>>>>>>>>>> can tell,
>>>>>>>>>>>> assuming that DDD() is actually called at some point, 
>>>>>>>>>>>> neither the
>>>>>>>>>>>> outer execution of DDD nor the nested (simulated) execution 
>>>>>>>>>>>> of DDD
>>>>>>>>>>>> can reach the return statement.  Infinite recursion might 
>>>>>>>>>>>> either
>>>>>>>>>>>> cause a stack overflow and a probable program crash, or an 
>>>>>>>>>>>> unending
>>>>>>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>>>>>>
>>>>>>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>>>>>>> reasonable level of programming experience.  (And it has 
>>>>>>>>>>>> nothing to
>>>>>>>>>>>> do with the halting problem as far as I can tell, though of 
>>>>>>>>>>>> course
>>>>>>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>>>>>>
>>>>>>>>>>>> Richard, what am I missing?
>>>>>>>>>>>>
>>>>>>>>>>> *****
>>>>>>>>>>> Now you are seeing what I was talking about.
>>>>>>>>>>> Now you are seeing why I needed to cross post
>>>>>>>>>>> to comp.lang.c
>>>>>>>>>>
>>>>>>>>>> What were you told in comp.lang.c that you were not told in 
>>>>>>>>>> comp.theory?
>>>>>>>>>
>>>>>>>>> void DDD()
>>>>>>>>> {
>>>>>>>>>    HHH(DDD);
>>>>>>>>>    return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> People quickly realize that when DDD is correctly
>>>>>>>>> simulated by HHH that DDD cannot possibly reach
>>>>>>>>> its "return" statement (final halt state).
>>>>>>>>>
>>>>>>>>> Once you know this then you can see that the
>>>>>>>>> same thing applies to DD.
>>>>>>>>>
>>>>>>>>> int DD()
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = HHH(DD);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> Once you know this then you know that the halting
>>>>>>>>> problem's otherwise "impossible" input is non-halting.
>>>>>>>>>
>>>>>>>>> Once you know this then you know that the halting
>>>>>>>>> problem proof has been correctly refuted.
>>>>>>>>
>>>>>>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>>>>>
>>>>>>> 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.
>>>>>>>  >
>>>>>>
>>>>>> What he says is true. However, the assumptions that HHH does a 
>>>>>> correct
>>>>>> simulation and that it does nothing else are not.
>>>>>>
>>>>>
>>>>> _DDD()
>>>>> [00002172] 55         push ebp      ; housekeeping
>>>>> [00002173] 8bec       mov ebp,esp   ; housekeeping
>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
>>>>> [0000217f] 83c404     add esp,+04
>>>>> [00002182] 5d         pop ebp
>>>>> [00002183] c3         ret
>>>>> Size in bytes:(0018) [00002183]
>>>>>
>>>>> We make an infinite set of purely hypothetical HHH pure
>>>>> x86 emulators each one is at machine address 000015d2
>>>>> thus called by DDD.
>>>>
>>>> And each DDD is a distinct algorithm.
>>>>
>>>
>>> Such that none of them halt.
>>> The only difference is the number of steps of DDD
>>> emulated by HHH.
>>
>> And the halt status of algorithm DDD has nothing to do with the halt 
>> status of algorithm DDD1, DDD2, etc.
>>
> 
> When the only difference between HHH/DDD pairs is that

They are different algorithms and therefore the halt status of one has 
nothing to do with the halt status of another.

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

#118719 — Re: Why I need to cross-post to comp.lang.c --- CORRECTLY REFUTED

On 5/12/2025 12:08 PM, dbush wrote:
> On 5/12/2025 12:59 PM, olcott wrote:
>> On 5/12/2025 11:42 AM, dbush wrote:
>>> On 5/12/2025 12:24 PM, olcott wrote:
>>>> On 5/12/2025 9:53 AM, dbush wrote:
>>>>> On 5/12/2025 10:47 AM, olcott wrote:
>>>>>> On 5/12/2025 2:45 AM, Mikko wrote:
>>>>>>> On 2025-05-11 16:03:29 +0000, olcott said:
>>>>>>>
>>>>>>>> On 5/11/2025 4:12 AM, Mikko wrote:
>>>>>>>>> On 2025-05-10 15:13:32 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 5/10/2025 2:15 AM, Mikko wrote:
>>>>>>>>>>> On 2025-05-09 03:01:40 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 5/8/2025 9:23 PM, Keith Thompson wrote:
>>>>>>>>>>>>> Richard Damon <richard@damon-family.org> writes:
>>>>>>>>>>>>>> On 5/8/25 7:53 PM, olcott wrote:
>>>>>>>>>>>>> [...]
>>>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>   HHH(DDD);
>>>>>>>>>>>>>>>   return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>> We don't need to look at any of my code for me
>>>>>>>>>>>>>>> to totally prove my point. For example when
>>>>>>>>>>>>>>> the above DDD is correctly simulated by HHH
>>>>>>>>>>>>>>> this simulated DDD cannot possibly reach its own
>>>>>>>>>>>>>>> "return" instruction.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And thus not correctly simulatd.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sorry, there is no "OS Exemption" to correct simulaiton;.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Perhaps I've missed something.  I don't see anything in the 
>>>>>>>>>>>>> above that
>>>>>>>>>>>>> implies that HHH does not correctly simulate DDD.  Richard, 
>>>>>>>>>>>>> you've read
>>>>>>>>>>>>> far more of olcott's posts than I have, so perhaps you can 
>>>>>>>>>>>>> clarify.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If we assume that HHH correctly simulates DDD, then the 
>>>>>>>>>>>>> above code is
>>>>>>>>>>>>> equivalent to:
>>>>>>>>>>>>>
>>>>>>>>>>>>> void DDD()
>>>>>>>>>>>>> {
>>>>>>>>>>>>> DDD();
>>>>>>>>>>>>> return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> which is a trivial case of infinite recursion.  As far as I 
>>>>>>>>>>>>> can tell,
>>>>>>>>>>>>> assuming that DDD() is actually called at some point, 
>>>>>>>>>>>>> neither the
>>>>>>>>>>>>> outer execution of DDD nor the nested (simulated) execution 
>>>>>>>>>>>>> of DDD
>>>>>>>>>>>>> can reach the return statement.  Infinite recursion might 
>>>>>>>>>>>>> either
>>>>>>>>>>>>> cause a stack overflow and a probable program crash, or an 
>>>>>>>>>>>>> unending
>>>>>>>>>>>>> loop if the compiler implements tail call optimization.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I see no contradiction, just an uninteresting case of infinite
>>>>>>>>>>>>> recursion, something that's well understood by anyone with a
>>>>>>>>>>>>> reasonable level of programming experience.  (And it has 
>>>>>>>>>>>>> nothing to
>>>>>>>>>>>>> do with the halting problem as far as I can tell, though of 
>>>>>>>>>>>>> course
>>>>>>>>>>>>> olcott has discussed the halting problem elsewhere.)
>>>>>>>>>>>>>
>>>>>>>>>>>>> Richard, what am I missing?
>>>>>>>>>>>>>
>>>>>>>>>>>> *****
>>>>>>>>>>>> Now you are seeing what I was talking about.
>>>>>>>>>>>> Now you are seeing why I needed to cross post
>>>>>>>>>>>> to comp.lang.c
>>>>>>>>>>>
>>>>>>>>>>> What were you told in comp.lang.c that you were not told in 
>>>>>>>>>>> comp.theory?
>>>>>>>>>>
>>>>>>>>>> void DDD()
>>>>>>>>>> {
>>>>>>>>>>    HHH(DDD);
>>>>>>>>>>    return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> People quickly realize that when DDD is correctly
>>>>>>>>>> simulated by HHH that DDD cannot possibly reach
>>>>>>>>>> its "return" statement (final halt state).
>>>>>>>>>>
>>>>>>>>>> Once you know this then you can see that the
>>>>>>>>>> same thing applies to DD.
>>>>>>>>>>
>>>>>>>>>> int DD()
>>>>>>>>>> {
>>>>>>>>>>    int Halt_Status = HHH(DD);
>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>    return Halt_Status;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Once you know this then you know that the halting
>>>>>>>>>> problem's otherwise "impossible" input is non-halting.
>>>>>>>>>>
>>>>>>>>>> Once you know this then you know that the halting
>>>>>>>>>> problem proof has been correctly refuted.
>>>>>>>>>
>>>>>>>>> You are lying again. Nothing above was told you in comp.lang.c.
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>  >
>>>>>>>
>>>>>>> What he says is true. However, the assumptions that HHH does a 
>>>>>>> correct
>>>>>>> simulation and that it does nothing else are not.
>>>>>>>
>>>>>>
>>>>>> _DDD()
>>>>>> [00002172] 55         push ebp      ; housekeeping
>>>>>> [00002173] 8bec       mov ebp,esp   ; housekeeping
>>>>>> [00002175] 6872210000 push 00002172 ; push DDD
>>>>>> [0000217a] e853f4ffff call 000015d2 ; call HHH(DDD)
>>>>>> [0000217f] 83c404     add esp,+04
>>>>>> [00002182] 5d         pop ebp
>>>>>> [00002183] c3         ret
>>>>>> Size in bytes:(0018) [00002183]
>>>>>>
>>>>>> We make an infinite set of purely hypothetical HHH pure
>>>>>> x86 emulators each one is at machine address 000015d2
>>>>>> thus called by DDD.
>>>>>
>>>>> And each DDD is a distinct algorithm.
>>>>>
>>>>
>>>> Such that none of them halt.
>>>> The only difference is the number of steps of DDD
>>>> emulated by HHH.
>>>
>>> And the halt status of algorithm DDD has nothing to do with the halt 
>>> status of algorithm DDD1, DDD2, etc.
>>>
>>
>> When the only difference between HHH/DDD pairs is that
> 
> They are different algorithms and therefore the halt status of one has 
> nothing to do with the halt status of another.

That is not true, this difference is not
the kind that can possibly change the halt status.

The difference is merely applying mathematical
induction to the exact same algorithm of HHH
emulating N steps of DDD.

-- 
Copyright 2024 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.theory

csiph-web