Path: ...!npeer.as286.net!npeer-ng0.as286.net!weretis.net!feeder8.news.weretis.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: "Fred. Zwarts" <F.Zwarts@HetNet.nl>
Newsgroups: comp.theory,sci.logic
Subject: Re: Two dozen people were simply wrong --- Try to prove otherwise ---
 pinned down
Date: Sun, 2 Jun 2024 20:59:32 +0200
Organization: A noiseless patient Spider
Lines: 282
Message-ID: <v3ifel$3f51j$13@dont-email.me>
References: <v3501h$lpnh$1@dont-email.me> <v3dft1$2lfup$1@i2pn2.org>
 <v3dhob$2dio8$1@dont-email.me> <v3dk0d$2lfup$2@i2pn2.org>
 <v3dkf2$2e2po$1@dont-email.me> <v3dmnc$2lfup$3@i2pn2.org>
 <v3do66$2ejq2$1@dont-email.me> <v3dqka$2lfup$4@i2pn2.org>
 <v3dsev$2f6ul$1@dont-email.me> <v3dtt4$2lfup$5@i2pn2.org>
 <v3dvr3$2jgjd$1@dont-email.me> <v3e0rj$2lfup$6@i2pn2.org>
 <v3e1m6$2jmc2$1@dont-email.me> <v3f09p$2n53o$1@i2pn2.org>
 <v3feqn$2rdp3$1@dont-email.me> <v3fgat$2n53n$5@i2pn2.org>
 <v3fhan$2rsbs$1@dont-email.me> <v3fi55$2n53o$6@i2pn2.org>
 <v3fiq7$2rsbs$5@dont-email.me> <v3flc5$2n53o$7@i2pn2.org>
 <v3flm8$2sm3s$1@dont-email.me> <v3fm1e$2n53n$8@i2pn2.org>
 <v3fmlc$2sogn$1@dont-email.me> <v3fncn$2n53n$9@i2pn2.org>
 <v3fo1p$2t1ac$2@dont-email.me> <v3fqpt$2tjjm$1@dont-email.me>
 <v3fu48$2ulbk$1@dont-email.me> <v3hchb$39j2d$2@dont-email.me>
 <v3i0ai$3cpu7$2@dont-email.me> <v3icns$3f51j$2@dont-email.me>
 <v3idr5$3f571$3@dont-email.me> <v3ierl$3f51j$8@dont-email.me>
 <v3if3l$3f571$8@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 02 Jun 2024 20:59:34 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="7b2dfb52a2545f32ded9b03629a80d37";
	logging-data="3642419"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+58JHUv0Y+X69OOhGdUNEj"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:pLumZsjGI186rlenZ3/xDPU8VxY=
Content-Language: en-GB
In-Reply-To: <v3if3l$3f571$8@dont-email.me>
Bytes: 14593

Op 02.jun.2024 om 20:53 schreef olcott:
> On 6/2/2024 1:49 PM, Fred. Zwarts wrote:
>> Op 02.jun.2024 om 20:32 schreef olcott:
>>> On 6/2/2024 1:13 PM, Fred. Zwarts wrote:
>>>> Op 02.jun.2024 om 16:41 schreef olcott:
>>>>> On 6/2/2024 4:03 AM, Fred. Zwarts wrote:
>>>>>> Op 01.jun.2024 om 21:51 schreef olcott:
>>>>>>> On 6/1/2024 1:54 PM, Fred. Zwarts wrote:
>>>>>>>> Op 01.jun.2024 om 20:07 schreef olcott:
>>>>>>>>> On 6/1/2024 12:56 PM, Richard Damon wrote:
>>>>>>>>>> On 6/1/24 1:44 PM, olcott wrote:
>>>>>>>>>>> On 6/1/2024 12:33 PM, Richard Damon wrote:
>>>>>>>>>>>> On 6/1/24 1:27 PM, olcott wrote:
>>>>>>>>>>>>> On 6/1/2024 12:22 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 6/1/24 12:38 PM, olcott wrote:
>>>>>>>>>>>>>>> On 6/1/2024 11:27 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 6/1/24 12:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 6/1/2024 10:56 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 6/1/24 11:30 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *I will not discuss any other points with you until 
>>>>>>>>>>>>>>>>>>> after you either*
>>>>>>>>>>>>>>>>>>> (a) Acknowledge that DD correctly simulated by HH and 
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ correctly
>>>>>>>>>>>>>>>>>>>      simulated by embedded_H remain stuck in 
>>>>>>>>>>>>>>>>>>> recursive simulation for
>>>>>>>>>>>>>>>>>>>      1 to ∞ of correct simulation or
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> (b) Correctly prove otherwise.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And until you answer the question of what that 
>>>>>>>>>>>>>>>>>> actually means, I will reply WHO CARES.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> typedef int (*ptr)();  // ptr is pointer to int 
>>>>>>>>>>>>>>>>> function in C
>>>>>>>>>>>>>>>>> 00       int HH(ptr p, ptr i);
>>>>>>>>>>>>>>>>> 01       int DD(ptr p)
>>>>>>>>>>>>>>>>> 02       {
>>>>>>>>>>>>>>>>> 03         int Halt_Status = HH(p, p);
>>>>>>>>>>>>>>>>> 04         if (Halt_Status)
>>>>>>>>>>>>>>>>> 05           HERE: goto HERE;
>>>>>>>>>>>>>>>>> 06         return Halt_Status;
>>>>>>>>>>>>>>>>> 07       }
>>>>>>>>>>>>>>>>> 08
>>>>>>>>>>>>>>>>> 09       int main()
>>>>>>>>>>>>>>>>> 10       {
>>>>>>>>>>>>>>>>> 11         HH(DD,DD);
>>>>>>>>>>>>>>>>> 12         return 0;
>>>>>>>>>>>>>>>>> 13       }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every DD correctly simulated by any HH of the infinite 
>>>>>>>>>>>>>>>>> set of HH/DD
>>>>>>>>>>>>>>>>> pairs that match the above template never reaches past 
>>>>>>>>>>>>>>>>> its own simulated
>>>>>>>>>>>>>>>>> line 03 in 1 to ∞ steps of correct simulation of DD by HH.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> In this case HH is either a pure simulator that never 
>>>>>>>>>>>>>>>>> halts or
>>>>>>>>>>>>>>>>> HH is a pure function that stops simulating after some 
>>>>>>>>>>>>>>>>> finite number
>>>>>>>>>>>>>>>>> of simulated lines. The line count is stored in a local 
>>>>>>>>>>>>>>>>> variable.
>>>>>>>>>>>>>>>>> The pure function HH always returns the meaningless 
>>>>>>>>>>>>>>>>> value of 56
>>>>>>>>>>>>>>>>> after it stops simulating.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, still no answer, to teh question. 
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You can pretend that you don't understand something that 
>>>>>>>>>>>>>>> you do indeed
>>>>>>>>>>>>>>> understand into perpetuity.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The key measure of dishonestly would be that you continue 
>>>>>>>>>>>>>>> to say
>>>>>>>>>>>>>>> that you don't understand yet never ever point out 
>>>>>>>>>>>>>>> exactly what you
>>>>>>>>>>>>>>> don't understand and why you don't understand it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I giuess that Mean YOU don't even know what you are 
>>>>>>>>>>>>>>>> asking, though it seems that now you are admitting that 
>>>>>>>>>>>>>>>> your HH doesn't actually ANSWER the question, so it 
>>>>>>>>>>>>>>>> isn't ACTUALL a decider for any function except the "56" 
>>>>>>>>>>>>>>>> mapping.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I will repeat the question and until you answer the 
>>>>>>>>>>>>>>>> question of what that actually means, I will reply WHO 
>>>>>>>>>>>>>>>> CARES.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> DO you mean the simulation of the TEMPLATE DD, 
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Of course I don't mean that nonsense. I mean exactly 
>>>>>>>>>>>>>>> what I specified*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> which means that we CAN'T simulate the call HH as we 
>>>>>>>>>>>>>>>> have no code past point to simulate, and thus your claim 
>>>>>>>>>>>>>>>> is just a LIE.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Or, do you mean a given instance of HH simulating a 
>>>>>>>>>>>>>>>> given instance of DD, at which point we never have the 1 
>>>>>>>>>>>>>>>> to infinte number of simulatons of THAT INPUT, so your 
>>>>>>>>>>>>>>>> claim is just a LIE.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every element of the infinite set of every H/D pairs...
>>>>>>>>>>>>>>> Every element of the infinite set of every H/D pairs...
>>>>>>>>>>>>>>> Every element of the infinite set of every H/D pairs...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Its not that hard when one refrains from dishonesty*
>>>>>>>>>>>>>>> We can't even say that you forgot these details from one 
>>>>>>>>>>>>>>> reply
>>>>>>>>>>>>>>> to the next because the details are still in this same post.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And every one gives a meaningless answer, 
>>>>>>>>>>>>>
>>>>>>>>>>>>> *THEN TRY TO REFUTE THIS UNEQUIVOCAL STATEMENT*
>>>>>>>>>>>>> DD correctly emulated by HH with an x86 emulator cannot 
>>>>>>>>>>>>> possibly
>>>>>>>>>>>>> reach past its own machine instruction [00001c2e] in any 
>>>>>>>>>>>>> finite
>>>>>>>>>>>>> number of steps of correct emulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Why? I don't care about it.
>>>>>>>>>>>>
>>>>>>>>>>>> As I have said, the implication of your definition of 
>>>>>>>>>>>> "Correct SImulation" means that this says NOTHING about the 
>>>>>>>>>>>> halting behavior of DD. (only not halted yet)
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *THEN TRY TO REFUTE THIS UNEQUIVOCAL STATEMENT*
>>>>>>>>>>> DD correctly emulated by HH with an x86 emulator cannot possibly
>>>>>>>>>>> reach past its own machine instruction [00001c2e] in any finite
>>>>>>>>>>> *or infinite* number of steps of correct emulation.
>>>>>>>>>>>
>>>>>>>>>>> When I say it that way you claim to be confused and what I do
>>>>>>>>>>> not say it that way you claim what I say is incomplete proof.
>>>>>>>>>>
>>>>>>>>>> WHy do I care? I won't spend the effort to even try to refute 
>>>>>>>>>> something that is clearly meaningless.
>>>>>>>>>>
>>>>>>>>>> You seem to have a conflict of definitions, as a given DD will 
>>>>>>>>>> only ever be simulated by ONE given HH that only simuates for 
>>>>>>>>>> one number of steps.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> typedef int (*ptr)();  // ptr is pointer to int function in C
>>>>>>>>> 00       int HH(ptr p, ptr i);
>>>>>>>>> 01       int DD(ptr p)
>>>>>>>>> 02       {
>>>>>>>>> 03         int Halt_Status = HH(p, p);
>>>>>>>>> 04         if (Halt_Status)
>>>>>>>>> 05           HERE: goto HERE;
>>>>>>>>> 06         return Halt_Status;
>>>>>>>>> 07       }
>>>>>>>>> 08
>>>>>>>>> 09       int main()
>>>>>>>>> 10       {
>>>>>>>>> 11         HH(DD,DD);
>>>>>>>>> 12         return 0;
========== REMAINDER OF ARTICLE TRUNCATED ==========