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 --- Very Stupid
 Mistake or Liars
Date: Fri, 14 Mar 2025 14:42:51 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <d2751116174b036b355145fa616711aee7fb515b@i2pn2.org>
References: <vqntaq$1jut5$1@dont-email.me> <vqqrin$28lh2$4@dont-email.me>
 <vqs9ck$2lqb2$1@dont-email.me> <vqud4e$36e14$3@dont-email.me>
 <vqueuk$idv$1@reader1.panix.com> <vqunb6$392on$1@dont-email.me>
 <0e710a3da76b08e532d6bbc56c3661ff0a0d9d92@i2pn2.org>
 <vr031n$ad6n$2@dont-email.me>
 <6378173d7e3d4629202da0afd62043e20b9e13d9@i2pn2.org>
 <vr097c$ehgd$2@dont-email.me>
 <9917d816e9bb08ba18b6d66967e998773d161eba@i2pn2.org>
 <vr1h36$1ev1a$8@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 18:42:52 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="187149"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
In-Reply-To: <vr1h36$1ev1a$8@dont-email.me>
Bytes: 7061
Lines: 139

On 3/14/25 11:13 AM, 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().
> 
> 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.
> 

Nope, which is why "Programs" need to include all the code they use.

Your problem is that your DDD doesn't include the actual code for HHH, 
or a precise definition of what that code does.

As you say, the HHH that DDD calls, and the HHH that is deciding on it 
must be identical as they are in the same location of memory,

If one execution frame of HHH, the one called from DDD gets stuck in an 
infinite loop, then ALL must do so, so your HHH can't abort its 
operations and return.

If you want to claim otherwise, you need to show the trace of the direct 
call of HHH from main, and the trace that HHH makes from the call in 
DDD, and show what the first instruction, ACTUALLY EMULATED by HHH that 
differed from the corresponding instruction in the direct execution of 
HHH where things differ.

The problem is that your "logic" is based on the concept that HHH 
doesn't need to actually show what it claims. Either you just claim that 
since one copy is too dumb to do what the other does since it doesn't 
get a chance to do that (which is a false statement) or is based on 
other false logic like the conditional to break the loop needs to be in 
the C function DDD, rather than anywhere in the actual PROGRAM DDD.

Sorry, you are just proving that you are just too stupid to understand 
what you are talking about, or even how stupid you are, That you have 
admitted that you statements are based on wrong definitions of words, 
and thus your work is just a FRAUD.