Re: Every sufficiently competent C programmer knows --- posthumous reviewers

On 3/13/25 8:54 PM, olcott wrote:

On 3/13/2025 4:15 PM, joes wrote:

Am Thu, 13 Mar 2025 15:56:22 -0500 schrieb olcott:

On 3/13/2025 4:22 AM, Mikko wrote:

On 2025-03-13 00:36:04 +0000, olcott said:
>

When HHH correctly emulates N steps of the above functions none of
them can possibly reach their own "return" instruction and terminate
normally.

>
Nevertheless, assuming HHH is a decider, Infinite_Loop and
Infinite_Recursion specify a non-terminating behaviour, DDD specifies a
terminating behaviour

>
_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]
>
What is the sequence of machine language instructions of DDD emulated by
HHH such that DDD reaches its machine address 00002183?

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

Which isn't a "Program", and can not be correctly emulated by HHH past the instruction at 0000217A
You have been told this many times, but choose to ignore it because you have choosen to stupidly ignore the definitions of the field, and just engage in DELIBERATE FRAUD

 

Depends on HHH, which we know 1) halts and 2) can't be simulated by
itself.
>

 Of the infinite set every possible HHH such that N
steps of DDD are correctly emulated by each HHH it
is a verified fact to anyone with sufficient technical
competence that no DDD ever reaches its own "ret"
instruction and terminates normally.

But for EVERY one of those HHH, when paired to your DDD template above to make a specific program DDD (which would NOW be a program), the fact that this HHH only emulates PARTIALLY and not to the end state says the emulation of such an HHH is NOT a "Correct Emulation", and that for ALL of these DDDs, the HHH that it calls WILL return and thus all of these DDD will return and halt, and thus ALL of your infinite set of HHH are wrong.
Your problem is you have started with a LIE as to what "DDD", and its behavior, actually refer to, and that lie has lead you to you total confusion and error.

 The same thing applies to this c code:
 void DDD()
{
   HHH(DDD);
   return;
}
 Anyone knowing this and failing to affirm it will
be construed as not wanting any honest dialogue.

No, you are proving that YOU are the one not wanting HONEST dialog, as your dialog begins with LIES.

 If people did not deny these facts for sadistic trollish
pleasure these same ideas can be applied to creating a
True(X) predicate to give LLM AI systems a foundation
anchored in facts thus eliminating AI Hallucinations.

No, YOU are the one that has admitted that you argument is based on the LIES of incorrect (as in changed) definition of the core defintions of the field.

 Such a system could eventually take on every user on
every social media platform and make the Nazi lies
look utterly ridiculous to even the liars themselves

Nope, you are just showing you don't know what you are talking about.
LLM have ZERO idea about "truth", only the most common token sequences.

 Before it can possibly do this it much know exactly
what True(X) is And how it works. True(X) begins
with a set of stipulated truths (basic facts that
cannot be derived from other basic facts).

Which is something a LLM can't know, as it isn't knowledge in the form that a LLM can use.

 Haskell Curry calls these the elementary theorems:
https://www.liarparadox.org/Haskell_Curry_45.pdf
 

Nope, you just don't understand what he is talking about. Not surprising, since you don't understand any of the details about how logic works.
All you are doing is proving you utter stupidity, and that all your work is based on the FRAUD of using equivocation and lies.