Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Every sufficiently competent C programmer knows --- posthumous
 reviewers
Date: Thu, 13 Mar 2025 23:03:57 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <ea99076f211d97f052fdedb91babdff9536c85ab@i2pn2.org>
References: <vqntaq$1jut5$1@dont-email.me> <vqp388$1tvqa$1@dont-email.me>
 <vqpdv9$202b2$2@dont-email.me> <vqperb$20c9k$2@dont-email.me>
 <E6mcnWv3nMa66036nZ2dnZfqnPWdnZ2d@brightview.co.uk>
 <vqpv2u$23vhr$1@dont-email.me>
 <Ny-dnRlMHcVpA036nZ2dnZfqnPqdnZ2d@brightview.co.uk>
 <vqrjrn$2h4l2$1@dont-email.me>
 <nESdnUfJxdhoTkz6nZ2dnZfqnPSdnZ2d@brightview.co.uk>
 <vqsl7c$2ok91$1@dont-email.me>
 <f7b6995ae3e79db00fa5070d9be8126b7ea5ae78@i2pn2.org>
 <vqt99l$2spcd$5@dont-email.me> <vqu84v$363tm$1@dont-email.me>
 <vqvgpn$3s1qt$4@dont-email.me>
 <f335df13f84c1d77cac488bd46bc631d99875b85@i2pn2.org>
 <vqvup1$59su$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Fri, 14 Mar 2025 03:03:58 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="82239"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <vqvup1$59su$2@dont-email.me>
Content-Language: en-US
Bytes: 6063
Lines: 118

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.