Path: ...!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: olcott <polcott333@gmail.com>
Newsgroups: comp.theory,sci.logic
Subject: Re: Two dozen people were simply wrong --- Try to prove otherwise ---
 pinned down
Date: Sun, 2 Jun 2024 09:19:50 -0500
Organization: A noiseless patient Spider
Lines: 166
Message-ID: <v3hv26$3bkv5$10@dont-email.me>
References: <v3501h$lpnh$1@dont-email.me> <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>
 <v3g0b9$2n53n$17@i2pn2.org> <v3g0q4$2v3lp$3@dont-email.me>
 <v3g2t2$2n53n$20@i2pn2.org> <v3g3ja$2vho5$1@dont-email.me>
 <v3g7eb$2n53n$23@i2pn2.org> <v3g80k$30c96$2@dont-email.me>
 <v3g99u$2n53n$24@i2pn2.org> <v3g9tc$30pbl$1@dont-email.me>
 <v3gaot$2n53n$26@i2pn2.org> <v3gp5p$36pdg$1@dont-email.me>
 <v3hmbv$2q5op$1@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 02 Jun 2024 16:19:51 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="3e1a2626012d6c432c11247ed1bf0353";
	logging-data="3527653"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+2hry+bmcdr2LOCrh2Qx6i"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:e9G3iyQbn186BxeMMbb+HO+sMss=
In-Reply-To: <v3hmbv$2q5op$1@i2pn2.org>
Content-Language: en-US
Bytes: 8023

On 6/2/2024 6:51 AM, Richard Damon wrote:
> On 6/1/24 11:33 PM, olcott wrote:
>> On 6/1/2024 6:27 PM, Richard Damon wrote:
>>> On 6/1/24 7:12 PM, olcott wrote:
>>>> On 6/1/2024 6:02 PM, Richard Damon wrote:
>>>>> On 6/1/24 6:40 PM, olcott wrote:
>>>>>>
>>>>>> Show me where I said anything in the above spec about an aborted 
>>>>>> simulation.
>>>>>
>>>>> So, why did HH stop simulating after some n steps?
>>>>>
>>>>> Did it reach a final state in the simulation? if not, it ABORTED 
>>>>> its simulation.
>>>>>
>>>>>>
>>>>>> When every possible which way DD correctly simulated by HH never 
>>>>>> reaches
>>>>>> past its own simulated line 03 then
>>>>>
>>>>> And a simulation either goes until it reaches a final state of the 
>>>>> machine it is simulating, or it aborted its simulation.
>>>>>
>>>>
>>>> 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       }
>>>>
>>>> When every DD correctly simulated by any HH cannot possibly reach
>>>> past its own simulated line 03 in 1 to ∞ steps of correct simulation
>>>> of DD by HH then we have exhaustively examined every possible HH/DD
>>>> pair and each element has of this infinite set has the same property.
>>>
>>> So?
>>>
>>> It doesn't matter how many aborted simulaiton you do of a given input 
>>> (and each HH simulated a DIFFERENT input since it simulated the 
>>> INSTANCE of the template with a different HH)
>>>
>>
>> In other words one cannot prove that every five pound rock weighs
>> more than every three pound rock, one must weigh them one-at-a-time?
> 
> Nope. But you need to show that each rock IS a five pound rock.
> 
> IF you weigh one rock, and find it is 5 pounds, doesn't mean that 
> anothoer rock  rock that looks about the same is also 5 pouds,
> 
> You do seem to like you Herring in Red sauce, don't you.
> 
> The comparison here is that you have only "weighed" a very few of your 
> DDs, only those built on an HH that NEVER aborts have been determined to 
> not halt. The others are just haven't-yet-halted-after-n-steps, but we 
> actually DO know that they WILL Halt after more.
> 
>>
>>> The ONLY simulation that actually showed that ITS input was 
>>> no-halting was the HH that never aborted, and it didn't answer.
>>>
>>> Every other HH has a DIFFERENT INPUT and would be LYING to say it had 
>>> that other input.
>>>
>>
>> In other words (because each rock is different) one cannot prove that 
>> every five pound rock weighs more than every three pound rock, one 
>> must weigh them one-at-a-time?
> Nope, unless of course you still need to weight them to show they ARE 5 
> pound rocks.
> 
>>
>> Every HH/DD pair of the infinite of every possible HH/DD pair
>> DD correctly simulated by HH NEVER HALTS.
> 
> That isn't even your original claim you were asking about.
> 
> Your claim wasn't about "Halting" because that is easily disproven, but 
> that there correct PARTIAL simulation done by H never reaches the 
> statement after the call.
> 
> You are just showing your true colors, that you just don't understand 
> what you are talkinag about and get your lies confused.
> 
>>
>>>>
>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>> *THIS PROVES THAT THE INPUT TO H(DD,DD) DOES NOT HALT*
>>>
>>> Nope. Aborted simulation don't prove anything.
>>>
>>
>> When for each element of the infinite set of every HH/DD pair DD
>> correctly simulated by HH cannot get past its own simulated line 03
>> then we know that none of the DD inputs to each HH(DD,DD) ever halts.
> 
> 
> Nope. Try to actually PROVE that.
> 

Semantic tautologies are self-evident truth that prove themselves.
It is a fact that every five pound rock weights more than any
three pound rock. No need to weigh any rocks.

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       }

Likewise we correctly deduce that for every HH/DD pair of the
infinite set of all HH/DD pairs that match the above template
every DD correctly simulated by HH never reaches past its own
simulated line 03, thus never halts.

*WHEN WE LOOK AS THE X86 MACHINE CODE OF DD THIS IS UNEQUIVOCAL*
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.

_DD()
[00001c22] 55         push ebp
[00001c23] 8bec       mov ebp,esp
[00001c25] 51         push ecx
[00001c26] 8b4508     mov eax,[ebp+08]
[00001c29] 50         push eax        ; push DD 1c22
[00001c2a] 8b4d08     mov ecx,[ebp+08]
[00001c2d] 51         push ecx        ; push DD 1c22
[00001c2e] e80ff7ffff call 00001342   ; call HH
[00001c33] 83c408     add esp,+08
[00001c36] 8945fc     mov [ebp-04],eax
[00001c39] 837dfc00   cmp dword [ebp-04],+00
[00001c3d] 7402       jz 00001c41
[00001c3f] ebfe       jmp 00001c3f
[00001c41] 8b45fc     mov eax,[ebp-04]
[00001c44] 8be5       mov esp,ebp
[00001c46] 5d         pop ebp
[00001c47] c3         ret
Size in bytes:(0038) [00001c47]


========== REMAINDER OF ARTICLE TRUNCATED ==========