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: Two dozen people were simply wrong --- Try to prove otherwise ---
 pinned down
Date: Sun, 2 Jun 2024 14:20:22 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <v3id56$2qu71$3@i2pn2.org>
References: <v3501h$lpnh$1@dont-email.me> <v3bduk$2im01$2@i2pn2.org>
 <v3bedb$22f8h$1@dont-email.me> <v3bfbm$2im01$3@i2pn2.org>
 <v3bg39$22o6m$1@dont-email.me> <v3cbhu$2k3ld$1@i2pn2.org>
 <v3clo2$28p7n$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> <v3fhmr$2ro2o$2@dont-email.me>
 <v3fhv0$2rsbs$4@dont-email.me> <v3fpun$2t8n0$1@dont-email.me>
 <v3fq64$2teib$1@dont-email.me> <v3frcl$2tjjm$2@dont-email.me>
 <v3fv9j$2utfl$1@dont-email.me> <v3hc3s$39j2d$1@dont-email.me>
 <v3i03m$3cpu7$1@dont-email.me> <v3ic3n$3f51j$1@dont-email.me>
 <v3ico6$3f830$2@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 18:20:22 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2980065"; 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: <v3ico6$3f830$2@dont-email.me>
Content-Language: en-US
Bytes: 8599
Lines: 157

On 6/2/24 2:13 PM, olcott wrote:
> On 6/2/2024 1:02 PM, Fred. Zwarts wrote:
>> Op 02.jun.2024 om 16:37 schreef olcott:
>>> On 6/2/2024 3:56 AM, Fred. Zwarts wrote:
>>>> Op 01.jun.2024 om 22:11 schreef olcott:
>>>>> On 6/1/2024 2:04 PM, Fred. Zwarts wrote:
>>>>>> Op 01.jun.2024 om 20:44 schreef olcott:
>>>>>>> On 6/1/2024 1:40 PM, Fred. Zwarts wrote:
>>>>>>>> Op 01.jun.2024 om 18:24 schreef olcott:
>>>>>>>>> On 6/1/2024 11:19 AM, Fred. Zwarts wrote:
>>>>>>>>>> Op 01.jun.2024 om 18:13 schreef olcott:
>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The simulated D never reaches past line 03, because the 
>>>>>>>>>> simulated HH never halts in 1 to ∞ steps of correct simulation 
>>>>>>>>>> of HH by HH.
>>>>>>>>>> I have told you that so many times.
>>>>>>>>>> HH is required to halt, thus HH does not match the requirement.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> HH correctly reports that because DD calls HH(DD,DD) in
>>>>>>>>> recursive simulation that DD never halts.
>>>>>>>>>
>>>>>>>>> HHH(HH,DD,DD) would report that HH halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Maybe. And H1 (DD,DD) would report that DD halts.
>>>>>>>>
>>>>>>>> In the recursive simulation by HH, neither the simulation of DD, 
>>>>>>>> nor the simulation of HH halts. If one of them would halt, the 
>>>>>>>> other one would halt as well.
>>>>>>>>
>>>>>>>> So HH 'correctly' reports that both DD and HH do not halt, 
>>>>>>>> because they both keep starting an instance of each other.
>>>>>>>
>>>>>>>
>>>>>>> I will not respond to any of your replies while you continue to play
>>>>>>> head games.
>>>>>>>
>>>>>>> *Changing the subject away from this is construed as a head game*
>>>>>>
>>>>>> Bad excuse. I am not changing the subject. I show that the 
>>>>>> requirements of HH in the subject are contradictory.
>>>>>>
>>>>>>> DD correctly simulated by pure function HH cannot possibly reach
>>>>>>> past its own line 03 in any finite number of steps of correct
>>>>>>> simulation.
>>>>>>
>>>>>> Only, because the simulation of HH did not halt.
>>>>>>
>>>>>>>
>>>>>>> In case you didn't know pure functions must halt because they must
>>>>>>> return a value.
>>>>>>>
>>>>>>
>>>>>> I know that HH is required to halt, but your own words implies 
>>>>>> that it doesn't. So apparently your HH does not match its 
>>>>>> requirements.
>>>>>>
>>>>>> Correct me if I am wrong and show the trace of the simulated HH 
>>>>>> that reaches its final state and the next 10 instructions.
>>>>>>
>>>>>
>>>>> Pages 4-5 of
>>>>> *The 2021-09-26 version of my first paper on simulating halt deciders*
>>>>> *Halting problem undecidability and infinitely nested simulation*
>>>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>>>>
>>>>
>>>> I looked at it, but I could not find where the ret instruction of 
>>>> the simulated H simulated by itself was printed. Could you please 
>>>> tell the page number? I want to know how the simulation proceeds 
>>>> after this return.
>>>> I only see the ret instruction simulated by another H. I hope it is 
>>>> not an attempt to change the subject.
>>>
>>> P correctly simulated by H cannot possibly reach its "ret" instruction.
>>> All of the instructions of H are screened out otherwise the execution
>>> trace of P would be mixed into with hundreds of other pages of P.
>>
>>
>> So, we agree that there is no proof that H correctly simulated by 
>> itself reaches its ret instruction.
>>
> 
> You just might not understand the subject matter will enough.
> As far as this proof goes (Maybe you need to read it again)
> 
> Pages 4-5 of
> *The 2021-09-26 version of my first paper on simulating halt deciders*
> *Halting problem undecidability and infinitely nested simulation*
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
> 
> We can tell that H has returned to main() because we see that after
> main() has called H(P,P) at its machine address [00000c63] the next
> instruction of main() [00000c68] is executed.

And by the same token, we can see that P(P) Halts, because if we have 
main call P(P) it will also return to main, assuming we have the same H 
that returned 0 for H(P,P)

So, that H is just wrong.

> 
>> So, I think we should also agree on the fact that HH above, when 
>> 'correctly' simulated by itself cannot possibly reach its own final 
>> state, because HH demonstrates a repeating state.
> 
> DD calling HH(DD,DD) demonstrates a repeating state that the executed
> HH recognizes and reports.
>