Re: Every sufficiently competent C programmer knows --- Very Stupid Mistake or Liars

On 3/13/25 9:41 AM, olcott wrote:

On 3/13/2025 6:18 AM, Dan Cross wrote:

In article <vqud4e$36e14$3@dont-email.me>,
Fred. Zwarts <F.Zwarts@HetNet.nl> wrote:

Op 12.mrt.2025 om 16:31 schreef olcott:

[snip]
When N steps of DDD are correctly emulated by every element
of the set of C functions named HHH that do x86 emulation and
>
N is each element of the set of natural numbers
>
then no DDD of the set of HHH/DDD pairs ever reaches its
"return" instruction and terminates normally.

>
In other words no HHH of the set of HHH/DDD pairs ever succeeds to
complete the simulation of a halting program. Failure to reach the end
of a halting program is not a great success. If all HHH in this set
fail, it would be better to change your mind and start working on
something more useful.

>
He seems to think that he's written a program that detects that
his thing hasn't 'reached its "return" instruction and
terminate[d] normally', given some number of steps, where that
number is ... the cardinality of the natural numbers.
>
I wonder if he knows that the set of natural numbers is
infintite, though I suspect he'd say something like, "but it's
countable!"  To which I'd surmise that he has no idea what that
means.
>

 void DDD()
{
   HHH(DDD);
   return;
}
 Everyone here knows that when N steps of DDD are correctly
simulated by HHH that DDD never reaches its own "return"
instruction and terminates normally thus never halts.
*AND THEY LIE ABOUT IT BY ENDLESSLY CHANGING THE SUBJECT*

No, the PARTIAL EMULATION done by HHH can't reach that point, but DD surely can, as any HHH that only emulates for N steps will return to its caller, and since it won't reach the end of its emulation of this input, will return 0.
That EVERY DD that calls an HHH that meets that specification will reach its final state and terminate shows that your HHH is just incorrect, because you just use unsound reasoning,  because you didn't understand the meaning of the words you used.
YOU are the one that doesn't understand the subject, that the "behavior" the input represents is, by definition, the behavior of actually running the program, and can't be the behavior of a partial emulation of this input, or that of another input that has the same code for the C function DD, but different code for the HHH that it calls.

 My posthumous reviewers will condemn them.
When DDD is correctly simulated by HHH once the behavior
of DDD exactly matches the infinite recursion behavior
pattern.

Nope, they will condemn you for not knowing what you are talking about, and see that you were too stupid to be willing to look at the actual definitions you just failed to learn

 int DD()
{
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
 We have the exact same effect when N steps of DD
are correctly emulated by HHH. I created DDD because
some of my reviewers are not technically competent
enough to see that line 2 of DD is unreachable code
when N steps of DD are correctly simulated by HHH.

No, you keep on changing thinking that this shows something different, but your DDD just makes it clearer, as DDD will ALWAYS halt independent of what HHH returns, whil DD can get into an infinite loop after the reuturn if for some reason you HHH returns 1.
All you are doing is proving that you are too stupid to learn the meaning of the terms you are using, and are so ignorant of how logic works, think it is ok to change them to what you want.
Sorry, but you have shown yourself to be THAT STUPID.

 

I plonked Olcott a few years ago, yet I see dozens of posts a
day a day of people replying to him.
>
I gather, based on reading the quoted text, that he is near the
end of a battle with cancer; that's very sad.  Perhaps he should
spend what time remains to him with friends and family, and less
arguing with strangers on USENET.  Maybe we could all help him
in this endeavor by not responding.  I, for one, intend to take
my own advice after this post.
>
  - Dan C.
>