Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory,sci.logic
Subject: Re: Olcott is simply wrong --- Try to prove otherwise --- pinned down
Date: Sun, 2 Jun 2024 13:22:16 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v3i9o8$2qu72$1@i2pn2.org>
References: <v3501h$lpnh$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>
 <v3hv26$3bkv5$10@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 2 Jun 2024 17:22:16 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2980066"; 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: <v3hv26$3bkv5$10@dont-email.me>
Bytes: 9591
Lines: 199

On 6/2/24 10:19 AM, olcott wrote:
> 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.

Right, so you don't need to weigh a five pound rock to know it is five 
bpounds.

> 
> 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.

Maybe the SIMULATION never reaches past it, but that doesn't mean the 
input (or the simulation) doesn't halt.

If H aborts its simulation, then the "simulation" reached its final 
state, that of being aborted. Yes, the machine simulated wasn't 
simulated to a final state, but the simulation did end.

And since H aborted its simulation, there is no evidence that the 
machine simulated will never reach a final state, and in fact, we can 
show that


So, your "Self-Evident Truth" is proved to be incorrect, just like so 
many of your "self-evident truths" because

> 
> *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.

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