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

Am Fri, 14 Mar 2025 10:58:39 -0500 schrieb olcott:

On 3/14/2025 10:55 AM, joes wrote:

Am Fri, 14 Mar 2025 10:13:41 -0500 schrieb olcott:

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:

 

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.

Important distinction.

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

Oh, I thought it was an unconditional simulator. The same code cannot
produce different behaviour.

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.

No. DDD always specifies the one same thing.

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

Uh no, there is only one call in either case. DD doesn't specify shit
"to HHH"; it doesn't know about its runtime environment.

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() directly executed in main().

Now *that* is impossible if I swapped their addresses. Not that you
could tell.

--
Am Sat, 20 Jul 2024 12:35:31 +0000 schrieb WM in sci.math:
It is not guaranteed that n+1 exists for every n.