Rocksolid Light

Welcome to Rocksolid Light

mail  files  register  newsreader  groups  login

Message-ID:  

19 May, 2024: Line wrapping has been changed to be more consistent with Usenet standards.
 If you find that it is broken please let me know here rocksolid.nodes.help

devel / comp.theory / Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

SubjectAuthor
* Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
|+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
|||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
|||  `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
|||   `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
|+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
|||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| | `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |  `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |   `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |    `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |     `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |      `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |       `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |        `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |         +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |         |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |         | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||| |         | |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |         | | `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||| |         | |  `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |         | |   `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||| |         | |    `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
||| |         | |     `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||| |         | |      `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFColcott
||| |         | |       +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior YES/NOolcott
||| |         | |       |`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior YES/NORichard Damon
||| |         | |       +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFCRichard Damon
||| |         | |       |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFColcott
||| |         | |       | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFCRichard Damon
||| |         | |       | |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFColcott
||| |         | |       | | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFCRichard Damon
||| |         | |       | | |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --aolcott
||| |         | |       | | ||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --aimmibis
||| |         | |       | | || `- H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesolcott
||| |         | |       | | |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --aolcott
||| |         | |       | | ||+* When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correctolcott
||| |         | |       | | |||+* Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correctMikko
||| |         | |       | | ||||`- Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correctRichard Damon
||| |         | |       | | |||`* Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correctolcott
||| |         | |       | | ||| `- Re: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correctolcott
||| |         | |       | | ||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | || `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --lRichard Damon
||| |         | |       | | |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --aRichard Damon
||| |         | |       | | | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | | |`- H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it seesolcott
||| |         | |       | | | | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | | |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --wRichard Damon
||| |         | |       | | | | ||+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --Oimmibis
||| |         | |       | | | | ||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --ORichard Damon
||| |         | |       | | | | |+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --wimmibis
||| |         | |       | | | | |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | | | `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | | |  +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | | |  |+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | | |  |+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | | |  |`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | | |  `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | | `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | |||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --wolcott
||| |         | |       | | | ||||+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --Oolcott
||| |         | |       | | | ||||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --Oolcott
||| |         | |       | | | |||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --ORichard Damon
||| |         | |       | | | ||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | || `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | ||  |+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  |+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | ||  ||+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  ||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | ||  |||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  ||||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | ||  |||+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  |||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | ||  ||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  || `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | ||  ||  `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  ||+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | ||  |||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | ||  ||`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | ||  || +* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  || |`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | ||  || `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | ||  |+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  ||+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | | ||  ||+- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  ||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | ||  |`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | ||  `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nimmibis
||| |         | |       | | | |`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nMikko
||| |         | |       | | | +- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nolcott
||| |         | |       | | | `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --nRichard Damon
||| |         | |       | | `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --aRichard Damon
||| |         | |       | `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFCimmibis
||| |         | |       `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFCimmibis
||| |         | `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
||| |         `- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||| `* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
||`- Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorRichard Damon
|`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott
+* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorimmibis
`* Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behaviorolcott

Pages:12345678910111213
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<usjhks$2qhfq$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55158&group=comp.theory#55158

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Date: Sat, 9 Mar 2024 23:49:15 -0600
Organization: A noiseless patient Spider
Lines: 212
Message-ID: <usjhks$2qhfq$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 05:49:16 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="2967034"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18YuRu/fVqrwRFlXMSdB9Ra"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:y1FGXmzhipOfsza3qmpdmS+65FM=
In-Reply-To: <usjgs6$1cf5q$7@i2pn2.org>
Content-Language: en-US
 by: olcott - Sun, 10 Mar 2024 05:49 UTC

On 3/9/2024 11:36 PM, Richard Damon wrote:
> On 3/9/24 9:14 PM, olcott wrote:
>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>> On 3/9/24 8:30 PM, olcott wrote:
>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows
>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means that
>>>>>>>>>>>>>>>> they
>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and
>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation
>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation
>>>>>>>>>>>>>> and
>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to
>>>>>>>>>>>>> use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>
>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>>>> They are objective. The answer to different people is the
>>>>>>>>>>> same answer if the criteria are objective.
>>>>>>>>>>
>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>> out of params.
>>>>>>>>>>
>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>> out of params.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>>>>> could do better. Write the Olcott machine (not x86utm) code for
>>>>>>>>> Ĥ and I would show you.
>>>>>>>>
>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>
>>>>>>> That's not a verified fact, that's just something you want to be
>>>>>>> true.
>>>>>>>
>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>>>> stupid it is, to say that an infinite loop halts?
>>>>>>>
>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>> to ⟨Ĥ⟩
>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>
>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>>>> IDENTICAL TO STEPS B AND C:
>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>> to ⟨Ĥ⟩
>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>> process
>>>>>>>
>>>>>>
>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of
>>>>>> params*
>>>>>>
>>>>>
>>>>> that isn't how any of this works. Do you even know what words mean?
>>>>
>>>> (b) and (c) are not the same as (1) and (2)
>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>
>>>
>>> Nope, your just being stuupid, perhaps intentionally.
>>> (c) just moves around to its simulation of a
>>>
>>>
>>> (a) H^.q0 (H^)
>>> H^ then makes a copy of its input
>>>
>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>> The algorithm of H begins a simulation of its input, watching the
>>> behaior of H^ (H^)
>>>
>>> (c) = (2)
>>> Which begins at the simulation of H^.q0 (H^)
>>>
>>> (d = sim a) = (sim a)
>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>
>>> (e = sim b) = (sim b)
>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of its
>>> input ...
>>>
>>> and so on.
>>>
>>> Both machine see EXACTLY the same level of details.
>>>
>>> Yes, the top level H is farther along at any given time then its
>>> simulated machine, and that is H's problem, it has to act before it
>>> sees how its simulation will respond to its copy of its actions.
>>>
>>> Thus, if it stops, it needs to make its decision "blind" and not with
>>> an idea of how the machine it is simulating will perform.
>>>
>>> If it doesn't stop, the level of recursion just keeps growing and no
>>> answer ever comes out.
>>
>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>> its simulation. Right before its cycle repeats the first time.
>>
>
>
> So?
>
> If it DOES abort there, then so will H^.H when it gets to that point in
> its simulation, which will be AFTER The point that H has stopped
> simulating it, so H doesn't know what H^ will do.
>
> Thus, if H DOES abort there, we presume from your previous answer it
> will think the input will not halt and answer qn.
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<usjj7v$1cf5q$8@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55159&group=comp.theory#55159

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Date: Sat, 9 Mar 2024 22:16:31 -0800
Organization: i2pn2 (i2pn.org)
Message-ID: <usjj7v$1cf5q$8@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 06:16:32 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1457338"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <usjhks$2qhfq$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
 by: Richard Damon - Sun, 10 Mar 2024 06:16 UTC

On 3/9/24 9:49 PM, olcott wrote:
> On 3/9/2024 11:36 PM, Richard Damon wrote:
>> On 3/9/24 9:14 PM, olcott wrote:
>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows
>>>>>>>>>>>>>>>>>>> what
>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means that
>>>>>>>>>>>>>>>>> they
>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and
>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to
>>>>>>>>>>>>>> use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>>>>> They are objective. The answer to different people is the
>>>>>>>>>>>> same answer if the criteria are objective.
>>>>>>>>>>>
>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>> out of params.
>>>>>>>>>>>
>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>> out of params.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>>>>>> could do better. Write the Olcott machine (not x86utm) code
>>>>>>>>>> for Ĥ and I would show you.
>>>>>>>>>
>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>
>>>>>>>> That's not a verified fact, that's just something you want to be
>>>>>>>> true.
>>>>>>>>
>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>>>>> stupid it is, to say that an infinite loop halts?
>>>>>>>>
>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>
>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>>>>> IDENTICAL TO STEPS B AND C:
>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>> process
>>>>>>>>
>>>>>>>
>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of
>>>>>>> params*
>>>>>>>
>>>>>>
>>>>>> that isn't how any of this works. Do you even know what words mean?
>>>>>
>>>>> (b) and (c) are not the same as (1) and (2)
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>>
>>>>
>>>> Nope, your just being stuupid, perhaps intentionally.
>>>> (c) just moves around to its simulation of a
>>>>
>>>>
>>>> (a) H^.q0 (H^)
>>>> H^ then makes a copy of its inp
>>>>
>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>> The algorithm of H begins a simulation of its input, watching the
>>>> behaior of H^ (H^)
>>>>
>>>> (c) = (2)
>>>> Which begins at the simulation of H^.q0 (H^)
>>>>
>>>> (d = sim a) = (sim a)
>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>
>>>> (e = sim b) = (sim b)
>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of its
>>>> input ...
>>>>
>>>> and so on.
>>>>
>>>> Both machine see EXACTLY the same level of details.
>>>>
>>>> Yes, the top level H is farther along at any given time then its
>>>> simulated machine, and that is H's problem, it has to act before it
>>>> sees how its simulation will respond to its copy of its actions.
>>>>
>>>> Thus, if it stops, it needs to make its decision "blind" and not
>>>> with an idea of how the machine it is simulating will perform.
>>>>
>>>> If it doesn't stop, the level of recursion just keeps growing and no
>>>> answer ever comes out.
>>>
>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>> its simulation. Right before its cycle repeats the first time.
>>>
>>
>>
>> So?
>>
>> If it DOES abort there, then so will H^.H when it gets to that point
>> in its simulation, which will be AFTER The point that H has stopped
>> simulating it, so H doesn't know what H^ will do.
>>
>> Thus, if H DOES abort there, we presume from your previous answer it
>> will think the input will not halt and answer qn.
>>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<uskg1p$30hr1$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55165&group=comp.theory#55165

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Date: Sun, 10 Mar 2024 09:28:09 -0500
Organization: A noiseless patient Spider
Lines: 245
Message-ID: <uskg1p$30hr1$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 14:28:09 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3164001"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18J4yyC+UHNm6IVjaaOph1p"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:KBh+GGi19iSZlFW9KFYwuwsiWTA=
Content-Language: en-US
In-Reply-To: <usjj7v$1cf5q$8@i2pn2.org>
 by: olcott - Sun, 10 Mar 2024 14:28 UTC

On 3/10/2024 12:16 AM, Richard Damon wrote:
> On 3/9/24 9:49 PM, olcott wrote:
>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>> On 3/9/24 9:14 PM, olcott wrote:
>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and
>>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to
>>>>>>>>>>>>>>> use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject is.
>>>>>>>>>>>>> They are objective. The answer to different people is the
>>>>>>>>>>>>> same answer if the criteria are objective.
>>>>>>>>>>>>
>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>> out of params.
>>>>>>>>>>>>
>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>> out of params.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>> monkey could do better. Write the Olcott machine (not x86utm)
>>>>>>>>>>> code for Ĥ and I would show you.
>>>>>>>>>>
>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>> not halt
>>>>>>>>>
>>>>>>>>> That's not a verified fact, that's just something you want to
>>>>>>>>> be true.
>>>>>>>>>
>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>>>>>> stupid it is, to say that an infinite loop halts?
>>>>>>>>>
>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>> process
>>>>>>>>>
>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>>>>>>> IDENTICAL TO STEPS B AND C:
>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>> process
>>>>>>>>>
>>>>>>>>
>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of
>>>>>>>> params*
>>>>>>>>
>>>>>>>
>>>>>>> that isn't how any of this works. Do you even know what words mean?
>>>>>>
>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>
>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>>>>>>
>>>>>
>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>> (c) just moves around to its simulation of a
>>>>>
>>>>>
>>>>> (a) H^.q0 (H^)
>>>>> H^ then makes a copy of its inp
>>>>>
>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>> The algorithm of H begins a simulation of its input, watching the
>>>>> behaior of H^ (H^)
>>>>>
>>>>> (c) = (2)
>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>
>>>>> (d = sim a) = (sim a)
>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>
>>>>> (e = sim b) = (sim b)
>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of its
>>>>> input ...
>>>>>
>>>>> and so on.
>>>>>
>>>>> Both machine see EXACTLY the same level of details.
>>>>>
>>>>> Yes, the top level H is farther along at any given time then its
>>>>> simulated machine, and that is H's problem, it has to act before it
>>>>> sees how its simulation will respond to its copy of its actions.
>>>>>
>>>>> Thus, if it stops, it needs to make its decision "blind" and not
>>>>> with an idea of how the machine it is simulating will perform.
>>>>>
>>>>> If it doesn't stop, the level of recursion just keeps growing and
>>>>> no answer ever comes out.
>>>>
>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>> its simulation. Right before its cycle repeats the first time.
>>>>
>>>
>>>
>>> So?
>>>
>>> If it DOES abort there, then so will H^.H when it gets to that point
>>> in its simulation, which will be AFTER The point that H has stopped
>>> simulating it, so H doesn't know what H^ will do.
>>>
>>> Thus, if H DOES abort there, we presume from your previous answer it
>>> will think the input will not halt and answer qn.
>>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> And if it does, as I said below, so will H^.H when it is run.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<KEkHN.386271$vFZa.185803@fx13.iad>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55170&group=comp.theory#55170

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!usenet.network!newsfeed.endofthelinebbs.com!weretis.net!feeder8.news.weretis.net!news.bawue.net!npeer.as286.net!npeer-ng0.as286.net!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla Thunderbird
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Newsgroups: comp.theory,sci.logic
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me>
From: Richard@Damon-Family.org (Richard Damon)
Content-Language: en-US
In-Reply-To: <uskg1p$30hr1$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 251
Message-ID: <KEkHN.386271$vFZa.185803@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sun, 10 Mar 2024 08:50:01 -0700
X-Received-Bytes: 12889
 by: Richard Damon - Sun, 10 Mar 2024 15:50 UTC

On 3/10/24 7:28 AM, olcott wrote:
> On 3/10/2024 12:16 AM, Richard Damon wrote:
>> On 3/9/24 9:49 PM, olcott wrote:
>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and
>>>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H
>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated
>>>>>>>>>>>>>>>> to use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject
>>>>>>>>>>>>>> is. They are objective. The answer to different people is
>>>>>>>>>>>>>> the same answer if the criteria are objective.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>
>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>>>> not halt
>>>>>>>>>>
>>>>>>>>>> That's not a verified fact, that's just something you want to
>>>>>>>>>> be true.
>>>>>>>>>>
>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>>>>>>>> stupid it is, to say that an infinite loop halts?
>>>>>>>>>>
>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>> process
>>>>>>>>>>
>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>> process
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of
>>>>>>>>> params*
>>>>>>>>>
>>>>>>>>
>>>>>>>> that isn't how any of this works. Do you even know what words mean?
>>>>>>>
>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>>>>> ⟨Ĥ⟩
>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>
>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
>>>>>>> see.
>>>>>>>
>>>>>>
>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>> (c) just moves around to its simulation of a
>>>>>>
>>>>>>
>>>>>> (a) H^.q0 (H^)
>>>>>> H^ then makes a copy of its inp
>>>>>>
>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>> The algorithm of H begins a simulation of its input, watching the
>>>>>> behaior of H^ (H^)
>>>>>>
>>>>>> (c) = (2)
>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>
>>>>>> (d = sim a) = (sim a)
>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>
>>>>>> (e = sim b) = (sim b)
>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of its
>>>>>> input ...
>>>>>>
>>>>>> and so on.
>>>>>>
>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>
>>>>>> Yes, the top level H is farther along at any given time then its
>>>>>> simulated machine, and that is H's problem, it has to act before
>>>>>> it sees how its simulation will respond to its copy of its actions.
>>>>>>
>>>>>> Thus, if it stops, it needs to make its decision "blind" and not
>>>>>> with an idea of how the machine it is simulating will perform.
>>>>>>
>>>>>> If it doesn't stop, the level of recursion just keeps growing and
>>>>>> no answer ever comes out.
>>>>>
>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>
>>>>
>>>>
>>>> So?
>>>>
>>>> If it DOES abort there, then so will H^.H when it gets to that point
>>>> in its simulation, which will be AFTER The point that H has stopped
>>>> simulating it, so H doesn't know what H^ will do.
>>>>
>>>> Thus, if H DOES abort there, we presume from your previous answer it
>>>> will think the input will not halt and answer qn.
>>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> And if it does, as I said below, so will H^.H when it is run.
>
> Yes.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uskog1$32h3c$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55171&group=comp.theory#55171

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 11:52:16 -0500
Organization: A noiseless patient Spider
Lines: 214
Message-ID: <uskog1$32h3c$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 16:52:17 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3228780"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19leYiIg6EkEjnuwV+QjJPw"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:/fKK7/lK57GSnlxp3NOMxX81hzw=
Content-Language: en-US
In-Reply-To: <KEkHN.386271$vFZa.185803@fx13.iad>
 by: olcott - Sun, 10 Mar 2024 16:52 UTC

On 3/10/2024 10:50 AM, Richard Damon wrote:
> On 3/10/24 7:28 AM, olcott wrote:
>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>> On 3/9/24 9:49 PM, olcott wrote:
>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>> and does not
>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H
>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated
>>>>>>>>>>>>>>>>> to use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject
>>>>>>>>>>>>>>> is. They are objective. The answer to different people is
>>>>>>>>>>>>>>> the same answer if the criteria are objective.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>
>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>> does not halt
>>>>>>>>>>>
>>>>>>>>>>> That's not a verified fact, that's just something you want to
>>>>>>>>>>> be true.
>>>>>>>>>>>
>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see
>>>>>>>>>>> how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>
>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>> process
>>>>>>>>>>>
>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>> process
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out
>>>>>>>>>> of params*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> that isn't how any of this works. Do you even know what words
>>>>>>>>> mean?
>>>>>>>>
>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>> to ⟨Ĥ⟩
>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>
>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
>>>>>>>> see.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>> (c) just moves around to its simulation of a
>>>>>>>
>>>>>>>
>>>>>>> (a) H^.q0 (H^)
>>>>>>> H^ then makes a copy of its inp
>>>>>>>
>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>> The algorithm of H begins a simulation of its input, watching the
>>>>>>> behaior of H^ (H^)
>>>>>>>
>>>>>>> (c) = (2)
>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>
>>>>>>> (d = sim a) = (sim a)
>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>
>>>>>>> (e = sim b) = (sim b)
>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of its
>>>>>>> input ...
>>>>>>>
>>>>>>> and so on.
>>>>>>>
>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>
>>>>>>> Yes, the top level H is farther along at any given time then its
>>>>>>> simulated machine, and that is H's problem, it has to act before
>>>>>>> it sees how its simulation will respond to its copy of its actions.
>>>>>>>
>>>>>>> Thus, if it stops, it needs to make its decision "blind" and not
>>>>>>> with an idea of how the machine it is simulating will perform.
>>>>>>>
>>>>>>> If it doesn't stop, the level of recursion just keeps growing and
>>>>>>> no answer ever comes out.
>>>>>>
>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>
>>>>>
>>>>>
>>>>> So?
>>>>>
>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>> point in its simulation, which will be AFTER The point that H has
>>>>> stopped simulating it, so H doesn't know what H^ will do.
>>>>>
>>>>> Thus, if H DOES abort there, we presume from your previous answer
>>>>> it will think the input will not halt and answer qn.
>>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> And if it does, as I said below, so will H^.H when it is run.
>>
>> Yes.
>
> And thus, H^.H will give the same answer as H,
> so H^ will act contrary to what H says,
> so H will give the wrong answer.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior YES/NO

<uskpar$32h3c$2@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55172&group=comp.theory#55172

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_YES/NO
Date: Sun, 10 Mar 2024 12:06:35 -0500
Organization: A noiseless patient Spider
Lines: 224
Message-ID: <uskpar$32h3c$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 17:06:35 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3228780"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/2ggg53OQ07pDN5Md1y6AX"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:wKhZF6n3P9Kn4POpdPaYNLerHY8=
In-Reply-To: <uskog1$32h3c$1@dont-email.me>
Content-Language: en-US
 by: olcott - Sun, 10 Mar 2024 17:06 UTC

On 3/10/2024 11:52 AM, olcott wrote:
> On 3/10/2024 10:50 AM, Richard Damon wrote:
>> On 3/10/24 7:28 AM, olcott wrote:
>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>> and does not
>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated
>>>>>>>>>>>>>>>>>> to use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject
>>>>>>>>>>>>>>>> is. They are objective. The answer to different people
>>>>>>>>>>>>>>>> is the same answer if the criteria are objective.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> That's not a verified fact, that's just something you want
>>>>>>>>>>>> to be true.
>>>>>>>>>>>>
>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see
>>>>>>>>>>>> how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>
>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>>> process
>>>>>>>>>>>>
>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>> the process
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out
>>>>>>>>>>> of params*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> that isn't how any of this works. Do you even know what words
>>>>>>>>>> mean?
>>>>>>>>>
>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>>
>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>> execution
>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> can see.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>
>>>>>>>>
>>>>>>>> (a) H^.q0 (H^)
>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>
>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>> The algorithm of H begins a simulation of its input, watching
>>>>>>>> the behaior of H^ (H^)
>>>>>>>>
>>>>>>>> (c) = (2)
>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>
>>>>>>>> (d = sim a) = (sim a)
>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>
>>>>>>>> (e = sim b) = (sim b)
>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of
>>>>>>>> its input ...
>>>>>>>>
>>>>>>>> and so on.
>>>>>>>>
>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>
>>>>>>>> Yes, the top level H is farther along at any given time then its
>>>>>>>> simulated machine, and that is H's problem, it has to act before
>>>>>>>> it sees how its simulation will respond to its copy of its actions.
>>>>>>>>
>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and not
>>>>>>>> with an idea of how the machine it is simulating will perform.
>>>>>>>>
>>>>>>>> If it doesn't stop, the level of recursion just keeps growing
>>>>>>>> and no answer ever comes out.
>>>>>>>
>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> So?
>>>>>>
>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>> point in its simulation, which will be AFTER The point that H has
>>>>>> stopped simulating it, so H doesn't know what H^ will do.
>>>>>>
>>>>>> Thus, if H DOES abort there, we presume from your previous answer
>>>>>> it will think the input will not halt and answer qn.
>>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> And if it does, as I said below, so will H^.H when it is run.
>>>
>>> Yes.
>>
>> And thus, H^.H will give the same answer as H,
>> so H^ will act contrary to what H says,
>> so H will give the wrong answer.
>
> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
> simulation to prevent their own infinite execution.
>
> Thus in the same way that ZFC conquered Russell's Paradox
> (by reframing the problem so that sets cannot refer to themselves)
> the Halting Problem can be conquered by reframing it.
>
> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
> (a) Their input halts H.qy
> (b) Their input fails to halt or has a pathological
> relationship to itself H.qn.
>


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uskpe3$32l00$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55173&group=comp.theory#55173

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news.x.richarddamon@xoxy.net (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 10:08:19 -0700
Organization: A noiseless patient Spider
Lines: 237
Message-ID: <uskpe3$32l00$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 17:08:20 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="f84be106c2593ae60617a756f00ce8c0";
logging-data="3232768"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19iydxKEGpXp8H1fV84lmaw1kxVI4uWM0g="
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:K9A05TYUGzwf2+gaNQzAqWxQqks=
In-Reply-To: <uskog1$32h3c$1@dont-email.me>
Content-Language: en-US
 by: Richard Damon - Sun, 10 Mar 2024 17:08 UTC

On 3/10/24 9:52 AM, olcott wrote:
> On 3/10/2024 10:50 AM, Richard Damon wrote:
>> On 3/10/24 7:28 AM, olcott wrote:
>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>> and does not
>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H
>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated
>>>>>>>>>>>>>>>>>> to use the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject
>>>>>>>>>>>>>>>> is. They are objective. The answer to different people
>>>>>>>>>>>>>>>> is the same answer if the criteria are objective.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>
>>>>>>>>>>>> That's not a verified fact, that's just something you want
>>>>>>>>>>>> to be true.
>>>>>>>>>>>>
>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see
>>>>>>>>>>>> how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>
>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>>> process
>>>>>>>>>>>>
>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>> the process
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out
>>>>>>>>>>> of params*
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> that isn't how any of this works. Do you even know what words
>>>>>>>>>> mean?
>>>>>>>>>
>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>>>>>
>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>> execution
>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> can see.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>
>>>>>>>>
>>>>>>>> (a) H^.q0 (H^)
>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>
>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>> The algorithm of H begins a simulation of its input, watching
>>>>>>>> the behaior of H^ (H^)
>>>>>>>>
>>>>>>>> (c) = (2)
>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>
>>>>>>>> (d = sim a) = (sim a)
>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>
>>>>>>>> (e = sim b) = (sim b)
>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of
>>>>>>>> its input ...
>>>>>>>>
>>>>>>>> and so on.
>>>>>>>>
>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>
>>>>>>>> Yes, the top level H is farther along at any given time then its
>>>>>>>> simulated machine, and that is H's problem, it has to act before
>>>>>>>> it sees how its simulation will respond to its copy of its actions.
>>>>>>>>
>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and not
>>>>>>>> with an idea of how the machine it is simulating will perform.
>>>>>>>>
>>>>>>>> If it doesn't stop, the level of recursion just keeps growing
>>>>>>>> and no answer ever comes out.
>>>>>>>
>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>
>>>>>>
>>>>>>
>>>>>> So?
>>>>>>
>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>> point in its simulation, which will be AFTER The point that H has
>>>>>> stopped simulating it, so H doesn't know what H^ will do.
>>>>>>
>>>>>> Thus, if H DOES abort there, we presume from your previous answer
>>>>>> it will think the input will not halt and answer qn.
>>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>
>>>> And if it does, as I said below, so will H^.H when it is run.
>>>
>>> Yes.
>>
>> And thus, H^.H will give the same answer as H,
>> so H^ will act contrary to what H says,
>> so H will give the wrong answer.
>
> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
> simulation to prevent their own infinite execution.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uskq04$32h3c$3@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55174&group=comp.theory#55174

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 12:17:56 -0500
Organization: A noiseless patient Spider
Lines: 271
Message-ID: <uskq04$32h3c$3@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 17:17:56 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3228780"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18UdN8Xawam07IwLJmb37NN"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:AUa0Z4wU/iWdIQLDrfDRjexwg0Q=
Content-Language: en-US
In-Reply-To: <uskpe3$32l00$1@dont-email.me>
 by: olcott - Sun, 10 Mar 2024 17:17 UTC

On 3/10/2024 12:08 PM, Richard Damon wrote:
> On 3/10/24 9:52 AM, olcott wrote:
>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>> On 3/10/24 7:28 AM, olcott wrote:
>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>> and does not
>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE criteria
>>>>>>>>>>>>>>>>>>> that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject
>>>>>>>>>>>>>>>>> is. They are objective. The answer to different people
>>>>>>>>>>>>>>>>> is the same answer if the criteria are objective.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> That's not a verified fact, that's just something you want
>>>>>>>>>>>>> to be true.
>>>>>>>>>>>>>
>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see
>>>>>>>>>>>>> how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>>>> process
>>>>>>>>>>>>>
>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>> the process
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out
>>>>>>>>>>>> of params*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> that isn't how any of this works. Do you even know what words
>>>>>>>>>>> mean?
>>>>>>>>>>
>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>> process
>>>>>>>>>>
>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>> execution
>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> can see.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>
>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>> The algorithm of H begins a simulation of its input, watching
>>>>>>>>> the behaior of H^ (H^)
>>>>>>>>>
>>>>>>>>> (c) = (2)
>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>
>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>
>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of
>>>>>>>>> its input ...
>>>>>>>>>
>>>>>>>>> and so on.
>>>>>>>>>
>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>
>>>>>>>>> Yes, the top level H is farther along at any given time then
>>>>>>>>> its simulated machine, and that is H's problem, it has to act
>>>>>>>>> before it sees how its simulation will respond to its copy of
>>>>>>>>> its actions.
>>>>>>>>>
>>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and
>>>>>>>>> not with an idea of how the machine it is simulating will perform.
>>>>>>>>>
>>>>>>>>> If it doesn't stop, the level of recursion just keeps growing
>>>>>>>>> and no answer ever comes out.
>>>>>>>>
>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> So?
>>>>>>>
>>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>>> point in its simulation, which will be AFTER The point that H has
>>>>>>> stopped simulating it, so H doesn't know what H^ will do.
>>>>>>>
>>>>>>> Thus, if H DOES abort there, we presume from your previous answer
>>>>>>> it will think the input will not halt and answer qn.
>>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>
>>>> Yes.
>>>
>>> And thus, H^.H will give the same answer as H,
>>> so H^ will act contrary to what H says,
>>> so H will give the wrong answer.
>>
>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>> simulation to prevent their own infinite execution.
>
> NOPE.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usks70$1enef$1@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55175&group=comp.theory#55175

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 10:55:44 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usks70$1enef$1@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 17:55:45 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <uskq04$32h3c$3@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
 by: Richard Damon - Sun, 10 Mar 2024 17:55 UTC

On 3/10/24 10:17 AM, olcott wrote:
> On 3/10/2024 12:08 PM, Richard Damon wrote:
>> On 3/10/24 9:52 AM, olcott wrote:
>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This
>>>>>>>>>>>>>>>>>>>>>>> means that they
>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>>> and does not
>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE criteria
>>>>>>>>>>>>>>>>>>>> that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>> different people is the same answer if the criteria
>>>>>>>>>>>>>>>>>> are objective.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That's not a verified fact, that's just something you want
>>>>>>>>>>>>>> to be true.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see
>>>>>>>>>>>>>> how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs
>>>>>>>>>>>>> out of params*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> that isn't how any of this works. Do you even know what
>>>>>>>>>>>> words mean?
>>>>>>>>>>>
>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>> process
>>>>>>>>>>>
>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>>> execution
>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>> can see.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>
>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>> The algorithm of H begins a simulation of its input, watching
>>>>>>>>>> the behaior of H^ (H^)
>>>>>>>>>>
>>>>>>>>>> (c) = (2)
>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>
>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>
>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of
>>>>>>>>>> its input ...
>>>>>>>>>>
>>>>>>>>>> and so on.
>>>>>>>>>>
>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>
>>>>>>>>>> Yes, the top level H is farther along at any given time then
>>>>>>>>>> its simulated machine, and that is H's problem, it has to act
>>>>>>>>>> before it sees how its simulation will respond to its copy of
>>>>>>>>>> its actions.
>>>>>>>>>>
>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and
>>>>>>>>>> not with an idea of how the machine it is simulating will
>>>>>>>>>> perform.
>>>>>>>>>>
>>>>>>>>>> If it doesn't stop, the level of recursion just keeps growing
>>>>>>>>>> and no answer ever comes out.
>>>>>>>>>
>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> So?
>>>>>>>>
>>>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>>>> point in its simulation, which will be AFTER The point that H
>>>>>>>> has stopped simulating it, so H doesn't know what H^ will do.
>>>>>>>>
>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>
>>>>> Yes.
>>>>
>>>> And thus, H^.H will give the same answer as H,
>>>> so H^ will act contrary to what H says,
>>>> so H will give the wrong answer.
>>>
>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>> simulation to prevent their own infinite execution.
>>
>> NOPE.
>
> If no source can be cited then the Olcott thesis
> "that no one did this before" remains unrefuted.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior

<usksng$33a1p$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55178&group=comp.theory#55178

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior
Date: Sun, 10 Mar 2024 19:04:32 +0100
Organization: A noiseless patient Spider
Lines: 120
Message-ID: <usksng$33a1p$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:04:32 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3254329"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+MIBl9goG7elqRrDsvgYGR"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:lGLf61eVPa9g4vA52ImI5KQMX5s=
In-Reply-To: <usjd20$2plge$1@dont-email.me>
Content-Language: en-US
 by: immibis - Sun, 10 Mar 2024 18:04 UTC

On 10/03/24 05:30, olcott wrote:
> On 3/9/2024 7:40 PM, immibis wrote:
>> On 10/03/24 02:37, olcott wrote:
>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>> On 10/03/24 02:29, olcott wrote:
>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Simulating halt deciders must make sure that they themselves
>>>>>>>>>>>>> do not get stuck in infinite execution. This means that they
>>>>>>>>>>>>> must abort every simulation that cannot possibly otherwise
>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation and does not
>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> aborts
>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive simulation H
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same objective
>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive simulation and
>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive simulation.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use
>>>>>>>>>> the exact same OBJECTIVE criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>
>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Objective criteria cannot vary based on who the subject is. They
>>>>>>>> are objective. The answer to different people is the same answer
>>>>>>>> if the criteria are objective.
>>>>>>>
>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>> out of params.
>>>>>>>
>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>> out of params.
>>>>>>>
>>>>>>
>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead monkey
>>>>>> could do better. Write the Olcott machine (not x86utm) code for Ĥ
>>>>>> and I would show you.
>>>>>
>>>>> *In other words you are denying these verified facts*
>>>>> *In other words you are denying these verified facts*
>>>>> *In other words you are denying these verified facts*
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> That's not a verified fact, that's just something you want to be true.
>>>>
>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see how
>>>> stupid it is, to say that an infinite loop halts?
>>>>
>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS PRECISELY
>>>> IDENTICAL TO STEPS B AND C:
>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to
>>>> ⟨Ĥ⟩
>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>
>>> *Yes and the key step of copying its input is left out so*
>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out of params*
>>>
>>
>> that isn't how any of this works. Do you even know what words mean?
>
> (b) and (c) are not the same as (1) and (2)
> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (2) which begins at simulated ⟨Ĥ.q0⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more execution
> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can see.
>

Because H and Ĥ.H ARE STIPULATED TO HAVE PRECISELY THE SAME BEHAVIOUR
WITH ABSOLUTELY NO EXCEPTIONS, they see the same number of execution
traces before they naturally halt.

The fact that H aborts its simulation before the point where simulated
Ĥ.H would have aborted its simulation does not mean that simulated Ĥ.H
would not have aborted its simulation.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior YES/NO

<usksod$1enef$4@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55179&group=comp.theory#55179

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_YES/NO
Date: Sun, 10 Mar 2024 11:05:00 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usksod$1enef$4@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpar$32h3c$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:05:02 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <uskpar$32h3c$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
 by: Richard Damon - Sun, 10 Mar 2024 18:05 UTC

On 3/10/24 10:06 AM, olcott wrote:
> On 3/10/2024 11:52 AM, olcott wrote:
>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>> On 3/10/24 7:28 AM, olcott wrote:
>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> knows what
>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that they
>>>>>>>>>>>>>>>>>>>>>> themselves
>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This means
>>>>>>>>>>>>>>>>>>>>>> that they
>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation
>>>>>>>>>>>>>>>>>>>>>> and does not
>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when Ĥ.H
>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE criteria
>>>>>>>>>>>>>>>>>>> that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the subject
>>>>>>>>>>>>>>>>> is. They are objective. The answer to different people
>>>>>>>>>>>>>>>>> is the same answer if the criteria are objective.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in recursive
>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>
>>>>>>>>>>>>> That's not a verified fact, that's just something you want
>>>>>>>>>>>>> to be true.
>>>>>>>>>>>>>
>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You see
>>>>>>>>>>>>> how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>>>> process
>>>>>>>>>>>>>
>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>> the process
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs out
>>>>>>>>>>>> of params*
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> that isn't how any of this works. Do you even know what words
>>>>>>>>>>> mean?
>>>>>>>>>>
>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied
>>>>>>>>>> to ⟨Ĥ⟩
>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>> process
>>>>>>>>>>
>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>> execution
>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> can see.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>
>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>> The algorithm of H begins a simulation of its input, watching
>>>>>>>>> the behaior of H^ (H^)
>>>>>>>>>
>>>>>>>>> (c) = (2)
>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>
>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>
>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of
>>>>>>>>> its input ...
>>>>>>>>>
>>>>>>>>> and so on.
>>>>>>>>>
>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>
>>>>>>>>> Yes, the top level H is farther along at any given time then
>>>>>>>>> its simulated machine, and that is H's problem, it has to act
>>>>>>>>> before it sees how its simulation will respond to its copy of
>>>>>>>>> its actions.
>>>>>>>>>
>>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and
>>>>>>>>> not with an idea of how the machine it is simulating will perform.
>>>>>>>>>
>>>>>>>>> If it doesn't stop, the level of recursion just keeps growing
>>>>>>>>> and no answer ever comes out.
>>>>>>>>
>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> So?
>>>>>>>
>>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>>> point in its simulation, which will be AFTER The point that H has
>>>>>>> stopped simulating it, so H doesn't know what H^ will do.
>>>>>>>
>>>>>>> Thus, if H DOES abort there, we presume from your previous answer
>>>>>>> it will think the input will not halt and answer qn.
>>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>
>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>
>>>> Yes.
>>>
>>> And thus, H^.H will give the same answer as H,
>>> so H^ will act contrary to what H says,
>>> so H will give the wrong answer.
>>
>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>> simulation to prevent their own infinite execution.
>>
>> Thus in the same way that ZFC conquered Russell's Paradox
>> (by reframing the problem so that sets cannot refer to themselves)
>> the Halting Problem can be conquered by reframing it.
>>
>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>> (a) Their input halts H.qy
>> (b) Their input fails to halt or has a pathological
>> relationship to itself H.qn.
>>
>
> Every yes/no question (including incorrect yes/no questions)
> can be correctly answered by:
> (a) YES
> (b) NOT YES
> Is this sentence true or false: "What time is it?" NOT TRUE
> Is this sentence true or false: "This sentence is not true." NOT TRUE
>


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uskssi$33a1p$4@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55182&group=comp.theory#55182

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 19:07:14 +0100
Organization: A noiseless patient Spider
Lines: 7
Message-ID: <uskssi$33a1p$4@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:07:14 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3254329"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+q4HdO3cGhSLjgPd/Oj8+S"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:q5+gkvWwxjejefAK8vwvpLawybE=
Content-Language: en-US
In-Reply-To: <uskog1$32h3c$1@dont-email.me>
 by: immibis - Sun, 10 Mar 2024 18:07 UTC

On 10/03/24 17:52, olcott wrote:
> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
> simulation to prevent their own infinite execution.

Wrong, they incorrectly determine this because they determine this even
though it is not true.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usksvk$33a1p$5@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55183&group=comp.theory#55183

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 19:08:52 +0100
Organization: A noiseless patient Spider
Lines: 22
Message-ID: <usksvk$33a1p$5@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:08:52 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3254329"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19O9TjEQyX5eh9+aveiyUrG"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:bqvvyV0OujuKjPBhyHJMBjGH5Gc=
Content-Language: en-US
In-Reply-To: <uskq04$32h3c$3@dont-email.me>
 by: immibis - Sun, 10 Mar 2024 18:08 UTC

On 10/03/24 18:17, olcott wrote:
> ZFC simply tossed out the Russell's Paradox question as unsound.

So you are saying that some Turing machines are not sound?

>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>> (a) Their input halts H.qy
>>> (b) Their input fails to halt or has a pathological
>>> relationship to itself H.qn.
>>
>> But the "Pathological Relationship" is ALLOWED.
>>
> ZFC simply tossed out the Russell's Paradox question as unsound
> expressly disallowing the "Pathological Relationship".

So you are saying that some Turing machines are not real Turing machines?

> I am only claiming that both H and Ĥ.H correctly say YES
> when their input halts and correctly say NOT YES otherwise.

well the halting problem requires them to correctly say NO, so you
haven't solved it

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usktro$33lov$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55185&group=comp.theory#55185

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 13:23:51 -0500
Organization: A noiseless patient Spider
Lines: 374
Message-ID: <usktro$33lov$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:23:52 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3266335"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19FYRlZ0ExxX2yu+y9LmkBU"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Di1DdVMT6aKAIQG2gMS4VWdUFDM=
Content-Language: en-US
In-Reply-To: <usks70$1enef$1@i2pn2.org>
 by: olcott - Sun, 10 Mar 2024 18:23 UTC

On 3/10/2024 12:55 PM, Richard Damon wrote:
> On 3/10/24 10:17 AM, olcott wrote:
>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>> On 3/10/24 9:52 AM, olcott wrote:
>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that
>>>>>>>>>>>>>>>>>>>>>>>> they themselves
>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This
>>>>>>>>>>>>>>>>>>>>>>>> means that they
>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot possibly
>>>>>>>>>>>>>>>>>>>>>>>> otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE criteria
>>>>>>>>>>>>>>>>>>>>> that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>> different people is the same answer if the criteria
>>>>>>>>>>>>>>>>>>> are objective.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a dead
>>>>>>>>>>>>>>>>> monkey could do better. Write the Olcott machine (not
>>>>>>>>>>>>>>>>> x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> halts
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> does not halt
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That's not a verified fact, that's just something you
>>>>>>>>>>>>>>> want to be true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You
>>>>>>>>>>>>>>> see how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs
>>>>>>>>>>>>>> out of params*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> that isn't how any of this works. Do you even know what
>>>>>>>>>>>>> words mean?
>>>>>>>>>>>>
>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>> process
>>>>>>>>>>>>
>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>>>> execution
>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>> can see.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>
>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>> The algorithm of H begins a simulation of its input, watching
>>>>>>>>>>> the behaior of H^ (H^)
>>>>>>>>>>>
>>>>>>>>>>> (c) = (2)
>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>
>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>
>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation of
>>>>>>>>>>> its input ...
>>>>>>>>>>>
>>>>>>>>>>> and so on.
>>>>>>>>>>>
>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>
>>>>>>>>>>> Yes, the top level H is farther along at any given time then
>>>>>>>>>>> its simulated machine, and that is H's problem, it has to act
>>>>>>>>>>> before it sees how its simulation will respond to its copy of
>>>>>>>>>>> its actions.
>>>>>>>>>>>
>>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and
>>>>>>>>>>> not with an idea of how the machine it is simulating will
>>>>>>>>>>> perform.
>>>>>>>>>>>
>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps growing
>>>>>>>>>>> and no answer ever comes out.
>>>>>>>>>>
>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So?
>>>>>>>>>
>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>>>>> point in its simulation, which will be AFTER The point that H
>>>>>>>>> has stopped simulating it, so H doesn't know what H^ will do.
>>>>>>>>>
>>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>> not halt
>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>
>>>>>> Yes.
>>>>>
>>>>> And thus, H^.H will give the same answer as H,
>>>>> so H^ will act contrary to what H says,
>>>>> so H will give the wrong answer.
>>>>
>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>> simulation to prevent their own infinite execution.
>>>
>>> NOPE.
>>
>> If no source can be cited then the Olcott thesis
>> "that no one did this before" remains unrefuted.
>
> Since, BY THE DEFINITIONS of what H MUST do to be correct, and what H^
> WILL do by its design, as shown in the Linz Proof.


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usku6m$33lov$2@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55186&group=comp.theory#55186

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 13:29:42 -0500
Organization: A noiseless patient Spider
Lines: 26
Message-ID: <usku6m$33lov$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskssi$33a1p$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:29:42 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3266335"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+KadmAvM+0w7GJkYAJJPyK"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:opgXf7grIaqYA0KIB5QTYnUMW+4=
Content-Language: en-US
In-Reply-To: <uskssi$33a1p$4@dont-email.me>
 by: olcott - Sun, 10 Mar 2024 18:29 UTC

On 3/10/2024 1:07 PM, immibis wrote:
> On 10/03/24 17:52, olcott wrote:
>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>> simulation to prevent their own infinite execution.
>
> Wrong, they incorrectly determine this because they determine this even
> though it is not true.

*Here is proof that what you said is counterfactual*
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process

*Since I proved that you are wrong about many times you must be a Troll*
*Since I proved that you are wrong about many times you must be a Troll*
*Since I proved that you are wrong about many times you must be a Troll*

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<uskubp$33lov$3@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55187&group=comp.theory#55187

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.quux.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 13:32:24 -0500
Organization: A noiseless patient Spider
Lines: 31
Message-ID: <uskubp$33lov$3@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 18:32:25 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3266335"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18CKTLsD9nGb9ngwQhLjEen"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:GL6dVElrFZLHze4WvFZc48GguSc=
Content-Language: en-US
In-Reply-To: <usksvk$33a1p$5@dont-email.me>
 by: olcott - Sun, 10 Mar 2024 18:32 UTC

On 3/10/2024 1:08 PM, immibis wrote:
> On 10/03/24 18:17, olcott wrote:
>> ZFC simply tossed out the Russell's Paradox question as unsound.
>
> So you are saying that some Turing machines are not sound?
>
>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>> (a) Their input halts H.qy
>>>> (b) Their input fails to halt or has a pathological
>>>> relationship to itself H.qn.
>>>
>>> But the "Pathological Relationship" is ALLOWED.
>>>
>> ZFC simply tossed out the Russell's Paradox question as unsound
>> expressly disallowing the "Pathological Relationship".
>
> So you are saying that some Turing machines are not real Turing machines?
>
>> I am only claiming that both H and Ĥ.H correctly say YES
>> when their input halts and correctly say NOT YES otherwise.
>
> well the halting problem requires them to correctly say NO, so you
> haven't solved it

All decision problem instances of program/input such that both
yes and no are the wrong answer toss out the input as invalid.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl0gn$34290$2@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55188&group=comp.theory#55188

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 20:09:11 +0100
Organization: A noiseless patient Spider
Lines: 25
Message-ID: <usl0gn$34290$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskssi$33a1p$4@dont-email.me>
<usku6m$33lov$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:09:11 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3279136"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19zeqNGbznxnWGpLzyXC5KH"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:V/TnS1tI1D0waL8vLtucDhbBfz4=
Content-Language: en-US
In-Reply-To: <usku6m$33lov$2@dont-email.me>
 by: immibis - Sun, 10 Mar 2024 19:09 UTC

On 10/03/24 19:29, olcott wrote:
> On 3/10/2024 1:07 PM, immibis wrote:
>> On 10/03/24 17:52, olcott wrote:
>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>> simulation to prevent their own infinite execution.
>>
>> Wrong, they incorrectly determine this because they determine this
>> even though it is not true.
>
> *Here is proof that what you said is counterfactual*
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Execution trace of Ĥ applied to ⟨Ĥ⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> *Since I proved that you are wrong about many times you must be a Troll*
> *Since I proved that you are wrong about many times you must be a Troll*
> *Since I proved that you are wrong about many times you must be a Troll*
>

where is the proof? I see a bunch of bullshit, but no proof.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl0hh$34290$3@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55189&group=comp.theory#55189

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 20:09:37 +0100
Organization: A noiseless patient Spider
Lines: 33
Message-ID: <usl0hh$34290$3@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:09:37 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3279136"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+BdrNOCN8BdGl3lxSn58TK"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:j9NxcHs6Kw6klICXNsELT06w+zU=
In-Reply-To: <uskubp$33lov$3@dont-email.me>
Content-Language: en-US
 by: immibis - Sun, 10 Mar 2024 19:09 UTC

On 10/03/24 19:32, olcott wrote:
> On 3/10/2024 1:08 PM, immibis wrote:
>> On 10/03/24 18:17, olcott wrote:
>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>
>> So you are saying that some Turing machines are not sound?
>>
>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>> (a) Their input halts H.qy
>>>>> (b) Their input fails to halt or has a pathological
>>>>> relationship to itself H.qn.
>>>>
>>>> But the "Pathological Relationship" is ALLOWED.
>>>>
>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>> expressly disallowing the "Pathological Relationship".
>>
>> So you are saying that some Turing machines are not real Turing machines?
>>
>>> I am only claiming that both H and Ĥ.H correctly say YES
>>> when their input halts and correctly say NOT YES otherwise.
>>
>> well the halting problem requires them to correctly say NO, so you
>> haven't solved it
>
> All decision problem instances of program/input such that both
> yes and no are the wrong answer toss out the input as invalid.
>

all decision problems are defined so that all instances are valid or
else they are not defined properly

all turing machine/input pairs are valid instances of the halting problem

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl0tc$347rv$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55190&group=comp.theory#55190

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 14:15:56 -0500
Organization: A noiseless patient Spider
Lines: 33
Message-ID: <usl0tc$347rv$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskssi$33a1p$4@dont-email.me>
<usku6m$33lov$2@dont-email.me> <usl0gn$34290$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:15:57 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3284863"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19ugwR8uLvmRy5rIKA+2YLi"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:rjR4joe5qu6p/JEkSXP3YlxVdjo=
Content-Language: en-US
In-Reply-To: <usl0gn$34290$2@dont-email.me>
 by: olcott - Sun, 10 Mar 2024 19:15 UTC

On 3/10/2024 2:09 PM, immibis wrote:
> On 10/03/24 19:29, olcott wrote:
>> On 3/10/2024 1:07 PM, immibis wrote:
>>> On 10/03/24 17:52, olcott wrote:
>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>> simulation to prevent their own infinite execution.
>>>
>>> Wrong, they incorrectly determine this because they determine this
>>> even though it is not true.
>>
>> *Here is proof that what you said is counterfactual*
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> *Since I proved that you are wrong about many times you must be a Troll*
>> *Since I proved that you are wrong about many times you must be a Troll*
>> *Since I proved that you are wrong about many times you must be a Troll*
>>
>
> where is the proof? I see a bunch of bullshit, but no proof.

The part that you erased Troll!!!

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl0u7$34bnj$1@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55191&group=comp.theory#55191

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: news@immibis.com (immibis)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 20:16:23 +0100
Organization: A noiseless patient Spider
Lines: 35
Message-ID: <usl0u7$34bnj$1@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:16:23 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="845e6215760786f6cdaa9dc04d48a147";
logging-data="3288819"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+2mLU7LeK7H74zZ2M6SI1o"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:fm3ZOwgjs94VcbxofnrazLSKYyw=
In-Reply-To: <uskubp$33lov$3@dont-email.me>
Content-Language: en-US
 by: immibis - Sun, 10 Mar 2024 19:16 UTC

On 10/03/24 19:32, olcott wrote:
> On 3/10/2024 1:08 PM, immibis wrote:
>> On 10/03/24 18:17, olcott wrote:
>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>
>> So you are saying that some Turing machines are not sound?
>>
>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>> (a) Their input halts H.qy
>>>>> (b) Their input fails to halt or has a pathological
>>>>> relationship to itself H.qn.
>>>>
>>>> But the "Pathological Relationship" is ALLOWED.
>>>>
>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>> expressly disallowing the "Pathological Relationship".
>>
>> So you are saying that some Turing machines are not real Turing machines?
>>
>>> I am only claiming that both H and Ĥ.H correctly say YES
>>> when their input halts and correctly say NOT YES otherwise.
>>
>> well the halting problem requires them to correctly say NO, so you
>> haven't solved it
>
> All decision problem instances of program/input such that both
> yes and no are the wrong answer toss out the input as invalid.

I noticed that you gave up on Olcott machines and now you are back to
your old bullshit ways of pretending that the same machine can produce
two different execution traces on the same input. Why don't you show us
an execution trace where that happens? Both traces must show the first
instruction that is different in both traces and I recommend showing 20
more instructions after that, but you can abort one after that time, if
it doesn't halt, to prevent the trace getting infinitely long.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl0v5$347rv$2@dont-email.me>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55192&group=comp.theory#55192

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: polcott2@gmail.com (olcott)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 14:16:52 -0500
Organization: A noiseless patient Spider
Lines: 43
Message-ID: <usl0v5$347rv$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0hh$34290$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:16:53 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="27c523feaef98dc1b326600190c611c0";
logging-data="3284863"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19Kd+gP3cZuZ/JNFDP2Pa7Z"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:O60EPf3Xjs8moRNlYF9CKA4VhWk=
In-Reply-To: <usl0hh$34290$3@dont-email.me>
Content-Language: en-US
 by: olcott - Sun, 10 Mar 2024 19:16 UTC

On 3/10/2024 2:09 PM, immibis wrote:
> On 10/03/24 19:32, olcott wrote:
>> On 3/10/2024 1:08 PM, immibis wrote:
>>> On 10/03/24 18:17, olcott wrote:
>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>
>>> So you are saying that some Turing machines are not sound?
>>>
>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>> (a) Their input halts H.qy
>>>>>> (b) Their input fails to halt or has a pathological
>>>>>> relationship to itself H.qn.
>>>>>
>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>
>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>> expressly disallowing the "Pathological Relationship".
>>>
>>> So you are saying that some Turing machines are not real Turing
>>> machines?
>>>
>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>> when their input halts and correctly say NOT YES otherwise.
>>>
>>> well the halting problem requires them to correctly say NO, so you
>>> haven't solved it
>>
>> All decision problem instances of program/input such that both
>> yes and no are the wrong answer toss out the input as invalid.
>>
>
> all decision problems are defined so that all instances are valid or
> else they are not defined properly
>

Not in the case of Russell's Paradox.

> all turing machine/input pairs are valid instances of the halting problem

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl1c7$1enef$9@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55193&group=comp.theory#55193

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 12:23:51 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usl1c7$1enef$9@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usks70$1enef$1@i2pn2.org>
<usktro$33lov$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:23:52 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; 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: <usktro$33lov$1@dont-email.me>
Content-Language: en-US
 by: Richard Damon - Sun, 10 Mar 2024 19:23 UTC

On 3/10/24 11:23 AM, olcott wrote:
> On 3/10/2024 12:55 PM, Richard Damon wrote:
>> On 3/10/24 10:17 AM, olcott wrote:
>>> On 3/10/2024 12:08 PM, Richard Damon wrote:
>>>> On 3/10/24 9:52 AM, olcott wrote:
>>>>> On 3/10/2024 10:50 AM, Richard Damon wrote:
>>>>>> On 3/10/24 7:28 AM, olcott wrote:
>>>>>>> On 3/10/2024 12:16 AM, Richard Damon wrote:
>>>>>>>> On 3/9/24 9:49 PM, olcott wrote:
>>>>>>>>> On 3/9/2024 11:36 PM, Richard Damon wrote:
>>>>>>>>>> On 3/9/24 9:14 PM, olcott wrote:
>>>>>>>>>>> On 3/9/2024 10:55 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/9/24 8:30 PM, olcott wrote:
>>>>>>>>>>>>> On 3/9/2024 7:40 PM, immibis wrote:
>>>>>>>>>>>>>> On 10/03/24 02:37, olcott wrote:
>>>>>>>>>>>>>>> On 3/9/2024 7:32 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 10/03/24 02:29, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/9/2024 7:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 10/03/24 01:30, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/9/2024 6:24 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 10/03/24 01:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:57 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>> On 10/03/24 00:26, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 5:10 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 23:22, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:50 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/03/24 22:34, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> What criteria would you use so that Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ knows what
>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong answer to provide?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact
>>>>>>>>>>>>>>>>>>>>>>>>>> same objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Simulating halt deciders must make sure that
>>>>>>>>>>>>>>>>>>>>>>>>> they themselves
>>>>>>>>>>>>>>>>>>>>>>>>> do not get stuck in infinite execution. This
>>>>>>>>>>>>>>>>>>>>>>>>> means that they
>>>>>>>>>>>>>>>>>>>>>>>>> must abort every simulation that cannot
>>>>>>>>>>>>>>>>>>>>>>>>> possibly otherwise halt.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> This requires Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation and does not
>>>>>>>>>>>>>>>>>>>>>>>>> require H ⟨Ĥ⟩ ⟨Ĥ⟩ to abort its simulation when
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts
>>>>>>>>>>>>>>>>>>>>>>>>> its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ does simulate itself in recursive
>>>>>>>>>>>>>>>>>>>>>>>>> simulation H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>>>>>>>>>>>>>> does not simulate itself in recursive simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is stipulated to use the exact same
>>>>>>>>>>>>>>>>>>>>>>>> objective criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Only because Ĥ.H is embedded within Ĥ and H is not*
>>>>>>>>>>>>>>>>>>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>>> simulation and
>>>>>>>>>>>>>>>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly get stuck in recursive
>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You dishonestly ignored that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>>>>>>>>>>>>>>>>>>>> stipulated to use the exact same OBJECTIVE
>>>>>>>>>>>>>>>>>>>>>> criteria that H ⟨Ĥ⟩ uses.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The above is true no matter what criteria that is used
>>>>>>>>>>>>>>>>>>>>> as long as H is a simulating halt decider.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Objective criteria cannot vary based on who the
>>>>>>>>>>>>>>>>>>>> subject is. They are objective. The answer to
>>>>>>>>>>>>>>>>>>>> different people is the same answer if the criteria
>>>>>>>>>>>>>>>>>>>> are objective.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ.H can get stuck in
>>>>>>>>>>>>>>>>>>> recursive
>>>>>>>>>>>>>>>>>>> simulation because Ĥ copies its input thus never runs
>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is objectively true that Ĥ cannot possibly get stuck
>>>>>>>>>>>>>>>>>>> in recursive because H does not copy its input thus runs
>>>>>>>>>>>>>>>>>>> out of params.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Wrong. Dead wrong. Stupidly wrong. So wrong that a
>>>>>>>>>>>>>>>>>> dead monkey could do better. Write the Olcott machine
>>>>>>>>>>>>>>>>>> (not x86utm) code for Ĥ and I would show you.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>> *In other words you are denying these verified facts*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ halts
>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to
>>>>>>>>>>>>>>>>> ⟨Ĥ⟩ does not halt
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That's not a verified fact, that's just something you
>>>>>>>>>>>>>>>> want to be true.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> ∞ means infinite loop. Infinite loop doesn't halt. You
>>>>>>>>>>>>>>>> see how stupid it is, to say that an infinite loop halts?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Execution trace of Ĥ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat
>>>>>>>>>>>>>>>>> the process
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ BECAUSE IT IS
>>>>>>>>>>>>>>>> PRECISELY IDENTICAL TO STEPS B AND C:
>>>>>>>>>>>>>>>>  > (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>>>  > (c) which begins at Ĥ's own simulated ⟨Ĥ.q0⟩ to
>>>>>>>>>>>>>>>> repeat the process
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Yes and the key step of copying its input is left out so*
>>>>>>>>>>>>>>> *H ⟨Ĥ⟩ ⟨Ĥ⟩ runs out of params and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ never runs
>>>>>>>>>>>>>>> out of params*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> that isn't how any of this works. Do you even know what
>>>>>>>>>>>>>> words mean?
>>>>>>>>>>>>>
>>>>>>>>>>>>> (b) and (c) are not the same as (1) and (2)
>>>>>>>>>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>>>>>>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>>>>>>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>>>>>>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩
>>>>>>>>>>>>> applied to ⟨Ĥ⟩
>>>>>>>>>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the
>>>>>>>>>>>>> process
>>>>>>>>>>>>>
>>>>>>>>>>>>> This means that Turing machine H ⟨Ĥ⟩ ⟨Ĥ⟩ can see one more
>>>>>>>>>>>>> execution
>>>>>>>>>>>>> trace of Ĥ ⟨Ĥ⟩ than its simulated Turing machine Ĥ.H ⟨Ĥ⟩
>>>>>>>>>>>>> ⟨Ĥ⟩ can see.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, your just being stuupid, perhaps intentionally.
>>>>>>>>>>>> (c) just moves around to its simulation of a
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> (a) H^.q0 (H^)
>>>>>>>>>>>> H^ then makes a copy of its inp
>>>>>>>>>>>>
>>>>>>>>>>>> (b) H^.H (H^) (H^) == (1) H (H^) (H^)
>>>>>>>>>>>> The algorithm of H begins a simulation of its input,
>>>>>>>>>>>> watching the behaior of H^ (H^)
>>>>>>>>>>>>
>>>>>>>>>>>> (c) = (2)
>>>>>>>>>>>> Which begins at the simulation of H^.q0 (H^)
>>>>>>>>>>>>
>>>>>>>>>>>> (d = sim a) = (sim a)
>>>>>>>>>>>> Ths Simulated H^.q0 (H^) makes a copy of its input
>>>>>>>>>>>>
>>>>>>>>>>>> (e = sim b) = (sim b)
>>>>>>>>>>>> The Simulated H^.H (H^) (H^) has is H begin the simulation
>>>>>>>>>>>> of its input ...
>>>>>>>>>>>>
>>>>>>>>>>>> and so on.
>>>>>>>>>>>>
>>>>>>>>>>>> Both machine see EXACTLY the same level of details.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, the top level H is farther along at any given time then
>>>>>>>>>>>> its simulated machine, and that is H's problem, it has to
>>>>>>>>>>>> act before it sees how its simulation will respond to its
>>>>>>>>>>>> copy of its actions.
>>>>>>>>>>>>
>>>>>>>>>>>> Thus, if it stops, it needs to make its decision "blind" and
>>>>>>>>>>>> not with an idea of how the machine it is simulating will
>>>>>>>>>>>> perform.
>>>>>>>>>>>>
>>>>>>>>>>>> If it doesn't stop, the level of recursion just keeps
>>>>>>>>>>>> growing and no answer ever comes out.
>>>>>>>>>>>
>>>>>>>>>>> The earliest point that H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly see to abort
>>>>>>>>>>> its simulation is immediately before Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ would begin
>>>>>>>>>>> its simulation. Right before its cycle repeats the first time.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> So?
>>>>>>>>>>
>>>>>>>>>> If it DOES abort there, then so will H^.H when it gets to that
>>>>>>>>>> point in its simulation, which will be AFTER The point that H
>>>>>>>>>> has stopped simulating it, so H doesn't know what H^ will do.
>>>>>>>>>>
>>>>>>>>>> Thus, if H DOES abort there, we presume from your previous
>>>>>>>>>> answer it will think the input will not halt and answer qn.
>>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does
>>>>>>>>> not halt
>>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts right after Ĥ.Hq0 before it simulates ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>>
>>>>>>>> And if it does, as I said below, so will H^.H when it is run.
>>>>>>>
>>>>>>> Yes.
>>>>>>
>>>>>> And thus, H^.H will give the same answer as H,
>>>>>> so H^ will act contrary to what H says,
>>>>>> so H will give the wrong answer.
>>>>>
>>>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>>>> simulation to prevent their own infinite execution.
>>>>
>>>> NOPE.
>>>
>>> If no source can be cited then the Olcott thesis
>>> "that no one did this before" remains unrefuted.
>>
>> Since, BY THE DEFINITIONS of what H MUST do to be correct, and what H^
>> WILL do by its design, as shown in the Linz Proof.
>
> If no source can be cited that shows a simulating halt decider can
> correctly determine that it must abort its simulation of the Halting
> Problem's pathological input to prevent its own non-termination, then
> innovation remains attributable to me.
>
> <snip>


Click here to read the complete article
Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl1k0$1enef$10@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55194&group=comp.theory#55194

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 12:28:00 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usl1k0$1enef$10@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:28:01 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <uskubp$33lov$3@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
 by: Richard Damon - Sun, 10 Mar 2024 19:28 UTC

On 3/10/24 11:32 AM, olcott wrote:
> On 3/10/2024 1:08 PM, immibis wrote:
>> On 10/03/24 18:17, olcott wrote:
>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>
>> So you are saying that some Turing machines are not sound?
>>
>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>> (a) Their input halts H.qy
>>>>> (b) Their input fails to halt or has a pathological
>>>>> relationship to itself H.qn.
>>>>
>>>> But the "Pathological Relationship" is ALLOWED.
>>>>
>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>> expressly disallowing the "Pathological Relationship".
>>
>> So you are saying that some Turing machines are not real Turing machines?
>>
>>> I am only claiming that both H and Ĥ.H correctly say YES
>>> when their input halts and correctly say NOT YES otherwise.
>>
>> well the halting problem requires them to correctly say NO, so you
>> haven't solved it
>
> All decision problem instances of program/input such that both
> yes and no are the wrong answer toss out the input as invalid.
>

And thus, ALL Problems are invalid, as there is always a decider that
gets the input wrong.

Remember, each instance of the Halting Problem has a FIXED DEFINED
input, that always has a right answer.

It is shown in a META-THEORY that for every decider, we can make an
input it won't get right, this these program/input pairs do not exist in
the theory, just the meta-theory, so we can't necessarily tell in the
theory of this issue.

You just don't understand logic well enough to understand it.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl2qh$1enef$11@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55196&group=comp.theory#55196

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 12:48:33 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usl2qh$1enef$11@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskpe3$32l00$1@dont-email.me>
<uskq04$32h3c$3@dont-email.me> <usksvk$33a1p$5@dont-email.me>
<uskubp$33lov$3@dont-email.me> <usl0hh$34290$3@dont-email.me>
<usl0v5$347rv$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:48:34 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <usl0v5$347rv$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
 by: Richard Damon - Sun, 10 Mar 2024 19:48 UTC

On 3/10/24 12:16 PM, olcott wrote:
> On 3/10/2024 2:09 PM, immibis wrote:
>> On 10/03/24 19:32, olcott wrote:
>>> On 3/10/2024 1:08 PM, immibis wrote:
>>>> On 10/03/24 18:17, olcott wrote:
>>>>> ZFC simply tossed out the Russell's Paradox question as unsound.
>>>>
>>>> So you are saying that some Turing machines are not sound?
>>>>
>>>>>>> Both H ⟨Ĥ⟩ ⟨Ĥ⟩ and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decide that:
>>>>>>> (a) Their input halts H.qy
>>>>>>> (b) Their input fails to halt or has a pathological
>>>>>>> relationship to itself H.qn.
>>>>>>
>>>>>> But the "Pathological Relationship" is ALLOWED.
>>>>>>
>>>>> ZFC simply tossed out the Russell's Paradox question as unsound
>>>>> expressly disallowing the "Pathological Relationship".
>>>>
>>>> So you are saying that some Turing machines are not real Turing
>>>> machines?
>>>>
>>>>> I am only claiming that both H and Ĥ.H correctly say YES
>>>>> when their input halts and correctly say NOT YES otherwise.
>>>>
>>>> well the halting problem requires them to correctly say NO, so you
>>>> haven't solved it
>>>
>>> All decision problem instances of program/input such that both
>>> yes and no are the wrong answer toss out the input as invalid.
>>>
>>
>> all decision problems are defined so that all instances are valid or
>> else they are not defined properly
>>
>
> Not in the case of Russell's Paradox.

Which is just Red Herring, as it has nothing to do with Halting.

It Turns out that for Set Theory, the fact that the rules for Naive Set
Theory allowed for results based Set Descriptions that are not actually
contructable, as their construction leads to a paradox, for Computation
Theory, the ability for Algortihms (aka Turing Machines) to contain
OTHER Algorithms (but never themselves, as that leads to in infinite
machine) but could take descriptions of themselves as input, leads to a
very useful system.

The "problem" you see, of having some questions not being answered by an
algorithm given data representing the specific instance of the question,
isn't considered actually a problem, since it turns out to have a fairly
reasonable explainion for its existance (which required transfinite math
to be discovered) which is that there are MANY more possible problems
then possible machine to decider them, being Aleph-1 possible problems,
but only Aleph-0 possible deciders.

Thus, currently the fact of uncomputable problems isn't considered an
issue by most, except crackpots like you.

>
>> all turing machine/input pairs are valid instances of the halting problem
>

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

<usl3dc$1enef$12@i2pn2.org>

  copy mid

https://news.novabbs.org/devel/article-flat.php?id=55197&group=comp.theory#55197

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!.POSTED!not-for-mail
From: richard@damon-family.org (Richard Damon)
Newsgroups: comp.theory,sci.logic
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ
⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behav
ior_ZFC
Date: Sun, 10 Mar 2024 12:58:36 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usl3dc$1enef$12@i2pn2.org>
References: <usia2e$2f2pd$1@dont-email.me> <usijm6$1bt2h$1@i2pn2.org>
<usikk8$2gnhr$8@dont-email.me> <usiljd$2hc10$3@dont-email.me>
<usineq$2hnpb$3@dont-email.me> <usiq9n$2ijsm$1@dont-email.me>
<usir82$2inqh$2@dont-email.me> <usit21$2j3c8$1@dont-email.me>
<usiufa$2j99n$1@dont-email.me> <usiukh$2jaj3$1@dont-email.me>
<usiuup$2jdc7$2@dont-email.me> <usj254$2jutc$2@dont-email.me>
<usj2e3$2jut2$1@dont-email.me> <usj2je$2jutc$3@dont-email.me>
<usj2rs$2jut2$2@dont-email.me> <usj32s$2k5id$1@dont-email.me>
<usjd20$2plge$1@dont-email.me> <usjef5$1cf5q$6@i2pn2.org>
<usjfj8$2q613$1@dont-email.me> <usjgs6$1cf5q$7@i2pn2.org>
<usjhks$2qhfq$1@dont-email.me> <usjj7v$1cf5q$8@i2pn2.org>
<uskg1p$30hr1$1@dont-email.me> <KEkHN.386271$vFZa.185803@fx13.iad>
<uskog1$32h3c$1@dont-email.me> <uskssi$33a1p$4@dont-email.me>
<usku6m$33lov$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sun, 10 Mar 2024 19:58:37 -0000 (UTC)
Injection-Info: i2pn2.org;
logging-data="1531343"; mail-complaints-to="usenet@i2pn2.org";
posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
In-Reply-To: <usku6m$33lov$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
 by: Richard Damon - Sun, 10 Mar 2024 19:58 UTC

On 3/10/24 11:29 AM, olcott wrote:
> On 3/10/2024 1:07 PM, immibis wrote:
>> On 10/03/24 17:52, olcott wrote:
>>> Unlike anything else that anyone else has ever done both H ⟨Ĥ⟩ ⟨Ĥ⟩
>>> and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ correctly determine that they must abort their own
>>> simulation to prevent their own infinite execution.
>>
>> Wrong, they incorrectly determine this because they determine this
>> even though it is not true.
>
> *Here is proof that what you said is counterfactual*
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy // Ĥ applied to ⟨Ĥ⟩ halts
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Execution trace of Ĥ applied to ⟨Ĥ⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> *Since I proved that you are wrong about many times you must be a Troll*
> *Since I proved that you are wrong about many times you must be a Troll*
> *Since I proved that you are wrong about many times you must be a Troll*
>

Since you just repeat the same arguement, and fail to point out errors
in the counter facts presents, it is clear that you KNOW you can't go
any deeper into you your argument, because like most lies, it falls
appart when looked at too closely.

H can't give the right answer, as what ever answer H gives, H^.H will
give, and thus H^ will do the opposite and make H wrong.

If your (c) is correct, and H^.H does just run forever, that means the
algorithm of H has no ability to detect a condition to stop it, and thus
H will never abort its simulation either, so it never answers, and fails
to be a decider.

This is perhaps the least wrong answer, as it at least doesn't GIVE a
wrong answer, just fails to answer at all, but still means H isn't a
Correct Halt Decider.

The fact that you keep repeating this and not learning, shows that you
have a serious learning impediment on this topic, and are just proving
your self to be a pathetic ignorant hypocritical pathological lying idiot.

devel / comp.theory / Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC

Pages:12345678910111213
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor