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

On Fri, 2025-03-14 at 10:13 -0500, olcott wrote:

On 3/14/2025 9:10 AM, Richard Damon wrote:

On 3/13/25 11:53 PM, olcott wrote:

On 3/13/2025 10:03 PM, Richard Damon wrote:

On 3/13/25 10:07 PM, olcott wrote:

On 3/13/2025 6:09 PM, Richard Damon wrote:

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 a complete emulation can?
 

 
Yes, but an HHH that gives an answer doesn't do one, due to the
pathological design of the template used to build DD to the HHH it
calls (which is the only HHH that can exist, or you have violated the
basic rules of programing and logic).
 
We have two basic cases,
 
1) if HHH does the partial emulation you describe, then the complete
emulation of DD will see that DD call HHH, and it will emulate its
input for a while, then abort and theu return 0 to DD which will then
halt.
 

 
int main()
{
   HHH(DDD); // No DDD can possibly ever return.
}
 

 
Since HHH doesn;t call DDD, the statement is vacuous and shows a
fundamental ignorance of what is being talked about.
 
Yes, No HHH can emulated DDD to the end, but since halting is DEFINED by
the behavior of the program, and for every HHH that aborts and returns,
the program of DDD, as tested with:
 
int main()
{
    DDD()
}
 
will return to main, that shows that every HHH that returns 0 fails to
be a Halt Decider or Termination Analyzer. PERIOD.
 
The fact that it may meet your defintion of POOP says maybe you have
solvec the POOP problem, but it seems you can't even properly define it
in the nornal field of Computation Theory.

 
void DDD()
{
   HHH(DDD);
   return;
}
 
The only difference between HHH and HHH1 is that they are
at different locations in memory. DDD simulated by HHH1
has identical behavior to DDD() executed in main().
 

https://en.wikipedia.org/wiki/Halting_problem
In computability theory, the halting problem is the problem of determining, from a description of an
arbitrary computer program and an input, whether the program will finish running, or continue to run
forever.

It is important to understand the meaning of the terms used in your question.
Otherwise, you are solving POO Problem. But, POOP is OK, just don't mix them.

The semantics of the finite string input DDD to HHH specifies
that it will continue to call HHH(DDD) in recursive simulation.
 
The semantics of the finite string input DDD to HHH1 specifies
to simulate to DDD exactly once.