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 --new focus--

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 ZFC --new focus--

<usm2ps$1enef$22@i2pn2.org>

  copy mid

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

  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_--new_focus--
Date: Sun, 10 Mar 2024 21:54:19 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usm2ps$1enef$22@i2pn2.org>
References: <usia2e$2f2pd$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>
<usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me>
<lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me>
<uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me>
<usm07p$1enef$21@i2pn2.org> <usm1sg$3ebq5$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 04:54:21 -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: <usm1sg$3ebq5$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
 by: Richard Damon - Mon, 11 Mar 2024 04:54 UTC

On 3/10/24 9:38 PM, olcott wrote:
> On 3/10/2024 11:10 PM, Richard Damon wrote:
>> On 3/10/24 8:33 PM, olcott wrote:
>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>> 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>
>>>>>>>>
>>>>>>>> Of course it can abort its simulation.
>>>>>>>>
>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>
>>>>>>>
>>>>>>> *I have always been using this long before I read about it*
>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>>>> backtracking. Superfluity means that the creator generates a
>>>>>>> variety of ideas, one or more of which turn out to be useless.
>>>>>>
>>>>>> But if you have mo idea how things actually works, this seems to
>>>>>> just generate random noise.
>>>>>>
>>>>>>>
>>>>>>> Backtracking signifies that the creator must often return to an
>>>>>>> earlier approach after blindly going off in the wrong direction.
>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>
>>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>>> simulating* *termination analyzer to the halting problem
>>>>>>> counter-example input*
>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>
>>>>>> Nope, I remember talk of that when I was in college, and they
>>>>>> showed why it can't work.
>>>>>>
>>>>>>>
>>>>>>>  From a programmer's point of view, if we apply an interpreter to a
>>>>>>> program text that includes a call to that same interpreter with that
>>>>>>> same text as argument, then we have an infinite loop. A halting
>>>>>>> program
>>>>>>> has some of the same character as an interpreter: it applies to
>>>>>>> texts
>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a
>>>>>>> halting
>>>>>>> program to a program text that includes a call to that same halting
>>>>>>> program with that same text as argument, then we have an infinite
>>>>>>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>
>>>>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter,
>>>>>> that doesn't hold.
>>>>>>
>>>>>> You seem to miss that fact.
>>>>>>
>>>>>>>
>>>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>
>>>>>>
>>>>>> And the reason it is a dead end is they make it too hard for you
>>>>>> to cheat.
>>>>>>
>>>>>> You need to hide that your H is trying to get in some extra
>>>>>> information to hide that the embedded version of H doesn't give
>>>>>> the same answer, which just shows that your H^ is built wrong.
>>>>>
>>>>> My C code proves these two have different behavior:
>>>>> (a) H1(D,D) + H1_machine_address
>>>>> (b) H(D,D) + H_machine_address
>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>
>>>>> I say:
>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>
>>>>> immibis disagrees.
>>>>> Correct reasoning will show who is correct.
>>>>>
>>>>
>>>> Yes, and since H1 is a different computation than H, it getting the
>>>> right answer doesn't keep H from being broken.
>>>>
>>>> We can then make a D1 to break H1.
>>>>
>>>
>>> I think that immibis already said that and I did not notice
>>> the significance of it at the time.
>>>
>>
>> Of course.
>>
>>> Then we are back to undecidability being incorrectly construed
>>> as an actual limit to computation.
>>
>> Strange definition of not an actual limit if not being able to do
>> something isn't a limit.
>>
>>>
>>> Professor's Hehner and Stoddart have only construed this as
>>> applying to the Halting Problem's pathological input.
>>>
>>> We three perfectly agree on this as it pertains to the
>>> Halting Problem.
>>>
>>> That two full PhD professors of computer science and I all
>>> agree on this shows that I am not a crackpot/crank on this.
>>> I think that all of the other options may now be exhausted.
>>>
>>> I am very happy that I quit tolerating the [change the subject]
>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>
>>> *The focus now must be on finding the best words that prove*
>>> *this original position of mine (thus the concurring positions*
>>> *of professors Hehner and Stoddart) is correct*
>>
>> Go knock yourself out on that.
>>
>>>
>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)
>>> sci.logic
>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>  > PREMISES:
>>>  > (1) The Halting Problem was specified in such a way that a solution
>>>  > was defined to be impossible.
>>
>> Nope.
>>
>> The PROBLEM is the question if a machine can compute the Halting
>> Function.
>>
>> The answer to that, has turned out to be NO.
>>
>> When the problem was first being posed, it was hoped the answer woudl
>> be yes, so it couldn't have bee made specifically to make it impossible.
>>
>>
>> The Halting QUESTION, has an answer for every input that it the
>> description of an actual algorithm applied to an actual data input.
>>
>> Note, Not a "Template" that gets appled to the decider, that IS an
>> invalid question, and impossible to build a description of a Turing
>> Machine to ask that.
>>
>> Thus, when you admitted that your input wasn't actually a description
>> of a program, but just a template, you were admitting that you were
>> lying about working on the Halting Problem, as your input isn't of the
>> right type.
>>
>> Yes, asking about a template IS an invalid question.
>>
>>>  >
>>>  > (2) The set of questions that are defined to not have any possible
>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>  > …
>>
>> And, when you are asking the actual Halting Question, about a specific
>> machine and input, like a SPECIFIC H^, built to foil a SPECIIFIC H,
>> then that input has a specific and definate behavior and there is a
>> specific and definate answer (That depends on the H that you chose to
>> build it on, but not the decider you are asking the question to).
>>
>>>  > CONCLUSION:
>>>  > Therefore the Halting Problem is an ill-formed question.
>>>  >
>>
>> Nope, as explained above. You are just showing that you never
>> understood the actual question or what any of the theory actually
>> means, and have just wasted the last decades of your life on a stupid
>> misconception of your own.
>>
>>> USENET Message-ID:
>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>
>>> *Direct Link to original message*
>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> That YES and NO are the wrong answer for each implementation of
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
> questions asked of these machine/inputs pairs are incorrect questions.
>
>
>


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

<usm3eg$3em6b$1@dont-email.me>

  copy mid

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

  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_--new_focus--
Date: Mon, 11 Mar 2024 00:05:19 -0500
Organization: A noiseless patient Spider
Lines: 492
Message-ID: <usm3eg$3em6b$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
<usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 05:05:20 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3627211"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19GGVUNhCiEHZPg6zYAfsU/"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:Lo/8kr3sOhrdTURwsM6RZ3OQdAg=
Content-Language: en-US
In-Reply-To: <usm2ps$1enef$22@i2pn2.org>
 by: olcott - Mon, 11 Mar 2024 05:05 UTC

On 3/10/2024 11:54 PM, Richard Damon wrote:
> On 3/10/24 9:38 PM, olcott wrote:
>> On 3/10/2024 11:10 PM, Richard Damon wrote:
>>> On 3/10/24 8:33 PM, olcott wrote:
>>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>>> 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>
>>>>>>>>>
>>>>>>>>> Of course it can abort its simulation.
>>>>>>>>>
>>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *I have always been using this long before I read about it*
>>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>>>>> backtracking. Superfluity means that the creator generates a
>>>>>>>> variety of ideas, one or more of which turn out to be useless.
>>>>>>>
>>>>>>> But if you have mo idea how things actually works, this seems to
>>>>>>> just generate random noise.
>>>>>>>
>>>>>>>>
>>>>>>>> Backtracking signifies that the creator must often return to an
>>>>>>>> earlier approach after blindly going off in the wrong direction.
>>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>>
>>>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>>>> simulating* *termination analyzer to the halting problem
>>>>>>>> counter-example input*
>>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>>
>>>>>>> Nope, I remember talk of that when I was in college, and they
>>>>>>> showed why it can't work.
>>>>>>>
>>>>>>>>
>>>>>>>>  From a programmer's point of view, if we apply an interpreter to a
>>>>>>>> program text that includes a call to that same interpreter with
>>>>>>>> that
>>>>>>>> same text as argument, then we have an infinite loop. A halting
>>>>>>>> program
>>>>>>>> has some of the same character as an interpreter: it applies to
>>>>>>>> texts
>>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a
>>>>>>>> halting
>>>>>>>> program to a program text that includes a call to that same halting
>>>>>>>> program with that same text as argument, then we have an
>>>>>>>> infinite loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>>
>>>>>>> You THINK so, but if the interpreter is a CONDITIONAL
>>>>>>> interpreter, that doesn't hold.
>>>>>>>
>>>>>>> You seem to miss that fact.
>>>>>>>
>>>>>>>>
>>>>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>>
>>>>>>>
>>>>>>> And the reason it is a dead end is they make it too hard for you
>>>>>>> to cheat.
>>>>>>>
>>>>>>> You need to hide that your H is trying to get in some extra
>>>>>>> information to hide that the embedded version of H doesn't give
>>>>>>> the same answer, which just shows that your H^ is built wrong.
>>>>>>
>>>>>> My C code proves these two have different behavior:
>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>> (b) H(D,D) + H_machine_address
>>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>>
>>>>>> I say:
>>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>
>>>>>> immibis disagrees.
>>>>>> Correct reasoning will show who is correct.
>>>>>>
>>>>>
>>>>> Yes, and since H1 is a different computation than H, it getting the
>>>>> right answer doesn't keep H from being broken.
>>>>>
>>>>> We can then make a D1 to break H1.
>>>>>
>>>>
>>>> I think that immibis already said that and I did not notice
>>>> the significance of it at the time.
>>>>
>>>
>>> Of course.
>>>
>>>> Then we are back to undecidability being incorrectly construed
>>>> as an actual limit to computation.
>>>
>>> Strange definition of not an actual limit if not being able to do
>>> something isn't a limit.
>>>
>>>>
>>>> Professor's Hehner and Stoddart have only construed this as
>>>> applying to the Halting Problem's pathological input.
>>>>
>>>> We three perfectly agree on this as it pertains to the
>>>> Halting Problem.
>>>>
>>>> That two full PhD professors of computer science and I all
>>>> agree on this shows that I am not a crackpot/crank on this.
>>>> I think that all of the other options may now be exhausted.
>>>>
>>>> I am very happy that I quit tolerating the [change the subject]
>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>>
>>>> *The focus now must be on finding the best words that prove*
>>>> *this original position of mine (thus the concurring positions*
>>>> *of professors Hehner and Stoddart) is correct*
>>>
>>> Go knock yourself out on that.
>>>
>>>>
>>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)
>>>> sci.logic
>>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>>  > PREMISES:
>>>>  > (1) The Halting Problem was specified in such a way that a solution
>>>>  > was defined to be impossible.
>>>
>>> Nope.
>>>
>>> The PROBLEM is the question if a machine can compute the Halting
>>> Function.
>>>
>>> The answer to that, has turned out to be NO.
>>>
>>> When the problem was first being posed, it was hoped the answer woudl
>>> be yes, so it couldn't have bee made specifically to make it impossible.
>>>
>>>
>>> The Halting QUESTION, has an answer for every input that it the
>>> description of an actual algorithm applied to an actual data input.
>>>
>>> Note, Not a "Template" that gets appled to the decider, that IS an
>>> invalid question, and impossible to build a description of a Turing
>>> Machine to ask that.
>>>
>>> Thus, when you admitted that your input wasn't actually a description
>>> of a program, but just a template, you were admitting that you were
>>> lying about working on the Halting Problem, as your input isn't of
>>> the right type.
>>>
>>> Yes, asking about a template IS an invalid question.
>>>
>>>>  >
>>>>  > (2) The set of questions that are defined to not have any possible
>>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>>  > …
>>>
>>> And, when you are asking the actual Halting Question, about a
>>> specific machine and input, like a SPECIFIC H^, built to foil a
>>> SPECIIFIC H, then that input has a specific and definate behavior and
>>> there is a specific and definate answer (That depends on the H that
>>> you chose to build it on, but not the decider you are asking the
>>> question to).
>>>
>>>>  > CONCLUSION:
>>>>  > Therefore the Halting Problem is an ill-formed question.
>>>>  >
>>>
>>> Nope, as explained above. You are just showing that you never
>>> understood the actual question or what any of the theory actually
>>> means, and have just wasted the last decades of your life on a stupid
>>> misconception of your own.
>>>
>>>> USENET Message-ID:
>>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>>
>>>> *Direct Link to original message*
>>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> That YES and NO are the wrong answer for each implementation of
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
>> questions asked of these machine/inputs pairs are incorrect questions.
>>
>>
>>
>
> Justs shows how must of a stupid idiot you are, because you just ignored
> the explaination.
>


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

<usm3ho$1enef$23@i2pn2.org>

  copy mid

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

  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_--RASP_Machines--
Date: Sun, 10 Mar 2024 22:07:03 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usm3ho$1enef$23@i2pn2.org>
References: <usia2e$2f2pd$1@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>
<usl0u7$34bnj$1@dont-email.me> <usljen$385ff$1@dont-email.me>
<hItHN.366352$q3F7.153154@fx45.iad> <uslrcc$3d3q0$1@dont-email.me>
<uslsgn$1enef$20@i2pn2.org> <usm1ib$3ebq5$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 05:07:06 -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: <usm1ib$3ebq5$1@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
 by: Richard Damon - Mon, 11 Mar 2024 05:07 UTC

On 3/10/24 9:33 PM, olcott wrote:
> On 3/10/2024 10:07 PM, Richard Damon wrote:
>> On 3/10/24 7:47 PM, olcott wrote:
>>> On 3/10/2024 9:08 PM, Richard Damon wrote:
>>>> On 3/10/24 5:32 PM, olcott wrote:
>>>>> On 3/10/2024 2:16 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.
>>>>>>
>>>>>> 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.
>>>>>
>>>>> Turing Machines and Olcott machines cannot properly implement
>>>>> H1(D,D) and H(D,D) that know their own machine address.
>>>>>
>>>>> My C code proves these two have different behavior:
>>>>> (a) H1(D,D) + H1_machine_address
>>>>> (b) H(D,D) + H_machine_address
>>>>>
>>>>> Because they are different computations they are
>>>>> not required to have the same behavior.
>>>>
>>>> Right, but it also means that since the dfference is because of a
>>>> "Hidden" input none of them qualify as a Halt Decider.
>>>>
>>>
>>> The key input (the machines own address) is not hidden
>>> merely unavailable to Turing machine and Olcott machines.
>>
>> And if it isn't hidden, then the other copies that take use a
>> different address become different computations and can't claim to
>> fill in for THE H.
>>
>> You then prove each copy wrong by giving it the version of H^/D that
>> is built on it, which it will get wrong.
>>
>> All the other ones might get it right, showing that there IS a correct
>> answer.
>>
>>>
>>>>>
>>>>> H(D,D) immediately sees the first time it calls itself
>>>>> with its same inputs.
>>>>>
>>>>> H1(D,D) never sees it call itself with its same inputs.
>>>>>
>>>>> Full Execution trace of H1(D,D)
>>>>> (a) main() invokes H1(D,D)
>>>>> (b) H1(D,D) simulates D(D)
>>>>> (c) Simulated D(D) calls simulated H(D,D)
>>>>> (d) Simulated H(D,D) simulates another D(D)
>>>>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>>>>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>>>>> (g) Simulated caller D(D) returns to H1(D,D)
>>>>> (h) H1(D,D) returns 1 to main()
>>>>>
>>>>> They cannot be implemented as Turing Machines or Olcott
>>>>> Machines. They can be implemented as RASP machines proven
>>>>> by the fact that they are implemented as C functions.
>>>>>
>>>>
>>>> Right, which proves your C functions also were never the required
>>>> computation, as they has an extra "hidden" input. As has been told
>>>> to you many times in the past.
>>>
>>> When I specify that every machine can know its own machine address
>>> in x86 machines and (possibly augmented) RASP machines then it is
>>> not hidden and an explicitly part of the input to the computation.
>>
>> And if it isn't hidden, then the other copies that take use a
>> different address become different computations and can't claim to
>> fill in for THE H.
>>
>> You then prove each copy wrong by giving it the version of H^/D that
>> is built on it, which it will get wrong.
>>
>> All the other ones might get it right, showing that there IS a correct
>> answer.
>>
>>>
>>>>
>>>> So, you just admitted that you hae just been lying for all these
>>>> years, and you are no closer to your fantasy goal then you ever were.
>>>>
>>>> Sorry, you just don't know enough to do this problem.
>>>
>>> I just admitted that it took me about two years to translate my
>>> intuitions into words that address your objections.
>>>
>>> For these two years you and many other people claimed that H1(D,D)
>>> could not possibly do what it actually did actually do. This has
>>> always been the same thing as disagreeing with arithmetic.
>>>
>>
>> It can't do it and be the SAME COMPUTATION as H, which is what you
>> were claiming.
>>
>
> It did actually do exactly what I claimed and everyone wanted
> to stick to their opinion and deny the actual facts that it
> did actually do what I said.

It might have done what you THOUGHT you were saying, but it doesn't do
what you ACTUALLY SAID.

THe problem is you MISUSED technical terms, because you didn't, and
apparently still don't, understand what they mean.

Either you have a sever learning disability, or you are just being
willfully ignorant (or both).

It was clearly asked, and yoyu confirmed, that H and H1 were claimed to
be the same COMPUTATION, which means they are only a function of there
declaired inputs, and the exact same algorithm, and neither H nor H1
take their address as a declared input, but somehow (we know how) manage
to do different things based on that value.

That mean, you DID LIE, and refusing it now, just makes it another LIE
showing your final destination.

>
>> You are now admitting you were lying all that time, and really owe an
>> appology to everyone yYOU said were lying when they were telling you
>> they weren't the same computation.
>>
> I never ever lied about any of these things.
> It took me a long time to get to closure because

You lied, perhaps because of ignorance, but that ignorance when well
past the ability to be called an "Honest Mistake" and became a wanton
disreguard for the truth.

>
> I tolerated the [change the subject] form of
> rebuttal that wasted 15 years with Ben Bacarisse.
>
> Once I stopped tolerating this closure was achieved
> on several points.
>
>> Of course, since you now admit they are different, that means that H1
>> can get H out of the jam. D will call the one instance of H, that one
>> particular computation, that it is designed to make wrong, and since
>> the other copies are different computations, they don't rescue that
>> one, or even show that the question is subjective.
>
> That they used their own machine address as part of their computation
> was explicitly provided for years. Don't blame me for lying when the
> real issue is that you didn't bother to pay attention.


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

<usm4id$1enef$24@i2pn2.org>

  copy mid

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

  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_--new_focus--
Date: Sun, 10 Mar 2024 22:24:29 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usm4id$1enef$24@i2pn2.org>
References: <usia2e$2f2pd$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>
<usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me>
<lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me>
<uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me>
<usm07p$1enef$21@i2pn2.org> <usm1sg$3ebq5$2@dont-email.me>
<usm2ps$1enef$22@i2pn2.org> <usm3eg$3em6b$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 05:24:30 -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
X-Spam-Checker-Version: SpamAssassin 4.0.0
In-Reply-To: <usm3eg$3em6b$1@dont-email.me>
 by: Richard Damon - Mon, 11 Mar 2024 05:24 UTC

On 3/10/24 10:05 PM, olcott wrote:
> On 3/10/2024 11:54 PM, Richard Damon wrote:
>> On 3/10/24 9:38 PM, olcott wrote:
>>> On 3/10/2024 11:10 PM, Richard Damon wrote:
>>>> On 3/10/24 8:33 PM, olcott wrote:
>>>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>>>> 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>
>>>>>>>>>>
>>>>>>>>>> Of course it can abort its simulation.
>>>>>>>>>>
>>>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *I have always been using this long before I read about it*
>>>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>>>> Two common phenomena characterize BVSR thinking: superfluity
>>>>>>>>> and backtracking. Superfluity means that the creator generates
>>>>>>>>> a variety of ideas, one or more of which turn out to be useless.
>>>>>>>>
>>>>>>>> But if you have mo idea how things actually works, this seems to
>>>>>>>> just generate random noise.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Backtracking signifies that the creator must often return to an
>>>>>>>>> earlier approach after blindly going off in the wrong direction.
>>>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>>>
>>>>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>>>>> simulating* *termination analyzer to the halting problem
>>>>>>>>> counter-example input*
>>>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>>>
>>>>>>>> Nope, I remember talk of that when I was in college, and they
>>>>>>>> showed why it can't work.
>>>>>>>>
>>>>>>>>>
>>>>>>>>>  From a programmer's point of view, if we apply an interpreter
>>>>>>>>> to a
>>>>>>>>> program text that includes a call to that same interpreter with
>>>>>>>>> that
>>>>>>>>> same text as argument, then we have an infinite loop. A halting
>>>>>>>>> program
>>>>>>>>> has some of the same character as an interpreter: it applies to
>>>>>>>>> texts
>>>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a
>>>>>>>>> halting
>>>>>>>>> program to a program text that includes a call to that same
>>>>>>>>> halting
>>>>>>>>> program with that same text as argument, then we have an
>>>>>>>>> infinite loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>>>
>>>>>>>> You THINK so, but if the interpreter is a CONDITIONAL
>>>>>>>> interpreter, that doesn't hold.
>>>>>>>>
>>>>>>>> You seem to miss that fact.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *Turing Machine and Olcott machine implementations seem to be
>>>>>>>>> dead*
>>>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And the reason it is a dead end is they make it too hard for you
>>>>>>>> to cheat.
>>>>>>>>
>>>>>>>> You need to hide that your H is trying to get in some extra
>>>>>>>> information to hide that the embedded version of H doesn't give
>>>>>>>> the same answer, which just shows that your H^ is built wrong.
>>>>>>>
>>>>>>> My C code proves these two have different behavior:
>>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>>> (b) H(D,D) + H_machine_address
>>>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>>>
>>>>>>> I say:
>>>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>
>>>>>>> immibis disagrees.
>>>>>>> Correct reasoning will show who is correct.
>>>>>>>
>>>>>>
>>>>>> Yes, and since H1 is a different computation than H, it getting
>>>>>> the right answer doesn't keep H from being broken.
>>>>>>
>>>>>> We can then make a D1 to break H1.
>>>>>>
>>>>>
>>>>> I think that immibis already said that and I did not notice
>>>>> the significance of it at the time.
>>>>>
>>>>
>>>> Of course.
>>>>
>>>>> Then we are back to undecidability being incorrectly construed
>>>>> as an actual limit to computation.
>>>>
>>>> Strange definition of not an actual limit if not being able to do
>>>> something isn't a limit.
>>>>
>>>>>
>>>>> Professor's Hehner and Stoddart have only construed this as
>>>>> applying to the Halting Problem's pathological input.
>>>>>
>>>>> We three perfectly agree on this as it pertains to the
>>>>> Halting Problem.
>>>>>
>>>>> That two full PhD professors of computer science and I all
>>>>> agree on this shows that I am not a crackpot/crank on this.
>>>>> I think that all of the other options may now be exhausted.
>>>>>
>>>>> I am very happy that I quit tolerating the [change the subject]
>>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>>>
>>>>> *The focus now must be on finding the best words that prove*
>>>>> *this original position of mine (thus the concurring positions*
>>>>> *of professors Hehner and Stoddart) is correct*
>>>>
>>>> Go knock yourself out on that.
>>>>
>>>>>
>>>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)
>>>>> sci.logic
>>>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>>>  > PREMISES:
>>>>>  > (1) The Halting Problem was specified in such a way that a solution
>>>>>  > was defined to be impossible.
>>>>
>>>> Nope.
>>>>
>>>> The PROBLEM is the question if a machine can compute the Halting
>>>> Function.
>>>>
>>>> The answer to that, has turned out to be NO.
>>>>
>>>> When the problem was first being posed, it was hoped the answer
>>>> woudl be yes, so it couldn't have bee made specifically to make it
>>>> impossible.
>>>>
>>>>
>>>> The Halting QUESTION, has an answer for every input that it the
>>>> description of an actual algorithm applied to an actual data input.
>>>>
>>>> Note, Not a "Template" that gets appled to the decider, that IS an
>>>> invalid question, and impossible to build a description of a Turing
>>>> Machine to ask that.
>>>>
>>>> Thus, when you admitted that your input wasn't actually a
>>>> description of a program, but just a template, you were admitting
>>>> that you were lying about working on the Halting Problem, as your
>>>> input isn't of the right type.
>>>>
>>>> Yes, asking about a template IS an invalid question.
>>>>
>>>>>  >
>>>>>  > (2) The set of questions that are defined to not have any possible
>>>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>>>  > …
>>>>
>>>> And, when you are asking the actual Halting Question, about a
>>>> specific machine and input, like a SPECIFIC H^, built to foil a
>>>> SPECIIFIC H, then that input has a specific and definate behavior
>>>> and there is a specific and definate answer (That depends on the H
>>>> that you chose to build it on, but not the decider you are asking
>>>> the question to).
>>>>
>>>>>  > CONCLUSION:
>>>>>  > Therefore the Halting Problem is an ill-formed question.
>>>>>  >
>>>>
>>>> Nope, as explained above. You are just showing that you never
>>>> understood the actual question or what any of the theory actually
>>>> means, and have just wasted the last decades of your life on a
>>>> stupid misconception of your own.
>>>>
>>>>> USENET Message-ID:
>>>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>>>
>>>>> *Direct Link to original message*
>>>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> That YES and NO are the wrong answer for each implementation of
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
>>> questions asked of these machine/inputs pairs are incorrect questions.
>>>
>>>
>>>
>>
>> Justs shows how must of a stupid idiot you are, because you just
>> ignored the explaination.
>>
>
> You don't seem to understand that every element of a set that shares
> common properties all have these same properties in common.


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

<usm5h9$3f27j$1@dont-email.me>

  copy mid

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

  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_--RASP_Machines--
Date: Mon, 11 Mar 2024 00:40:56 -0500
Organization: A noiseless patient Spider
Lines: 272
Message-ID: <usm5h9$3f27j$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me> <hItHN.366352$q3F7.153154@fx45.iad>
<uslrcc$3d3q0$1@dont-email.me> <uslsgn$1enef$20@i2pn2.org>
<usm1ib$3ebq5$1@dont-email.me> <usm3ho$1enef$23@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 05:40:57 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3639539"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+HkHU21o0RCaT78y7/WwEM"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:BrDxWuiF4QHDW/V8KXZlflnW7Ok=
Content-Language: en-US
In-Reply-To: <usm3ho$1enef$23@i2pn2.org>
 by: olcott - Mon, 11 Mar 2024 05:40 UTC

On 3/11/2024 12:07 AM, Richard Damon wrote:
> On 3/10/24 9:33 PM, olcott wrote:
>> On 3/10/2024 10:07 PM, Richard Damon wrote:
>>> On 3/10/24 7:47 PM, olcott wrote:
>>>> On 3/10/2024 9:08 PM, Richard Damon wrote:
>>>>> On 3/10/24 5:32 PM, olcott wrote:
>>>>>> On 3/10/2024 2:16 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.
>>>>>>>
>>>>>>> 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.
>>>>>>
>>>>>> Turing Machines and Olcott machines cannot properly implement
>>>>>> H1(D,D) and H(D,D) that know their own machine address.
>>>>>>
>>>>>> My C code proves these two have different behavior:
>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>> (b) H(D,D) + H_machine_address
>>>>>>
>>>>>> Because they are different computations they are
>>>>>> not required to have the same behavior.
>>>>>
>>>>> Right, but it also means that since the dfference is because of a
>>>>> "Hidden" input none of them qualify as a Halt Decider.
>>>>>
>>>>
>>>> The key input (the machines own address) is not hidden
>>>> merely unavailable to Turing machine and Olcott machines.
>>>
>>> And if it isn't hidden, then the other copies that take use a
>>> different address become different computations and can't claim to
>>> fill in for THE H.
>>>
>>> You then prove each copy wrong by giving it the version of H^/D that
>>> is built on it, which it will get wrong.
>>>
>>> All the other ones might get it right, showing that there IS a
>>> correct answer.
>>>
>>>>
>>>>>>
>>>>>> H(D,D) immediately sees the first time it calls itself
>>>>>> with its same inputs.
>>>>>>
>>>>>> H1(D,D) never sees it call itself with its same inputs.
>>>>>>
>>>>>> Full Execution trace of H1(D,D)
>>>>>> (a) main() invokes H1(D,D)
>>>>>> (b) H1(D,D) simulates D(D)
>>>>>> (c) Simulated D(D) calls simulated H(D,D)
>>>>>> (d) Simulated H(D,D) simulates another D(D)
>>>>>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>>>>>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>>>>>> (g) Simulated caller D(D) returns to H1(D,D)
>>>>>> (h) H1(D,D) returns 1 to main()
>>>>>>
>>>>>> They cannot be implemented as Turing Machines or Olcott
>>>>>> Machines. They can be implemented as RASP machines proven
>>>>>> by the fact that they are implemented as C functions.
>>>>>>
>>>>>
>>>>> Right, which proves your C functions also were never the required
>>>>> computation, as they has an extra "hidden" input. As has been told
>>>>> to you many times in the past.
>>>>
>>>> When I specify that every machine can know its own machine address
>>>> in x86 machines and (possibly augmented) RASP machines then it is
>>>> not hidden and an explicitly part of the input to the computation.
>>>
>>> And if it isn't hidden, then the other copies that take use a
>>> different address become different computations and can't claim to
>>> fill in for THE H.
>>>
>>> You then prove each copy wrong by giving it the version of H^/D that
>>> is built on it, which it will get wrong.
>>>
>>> All the other ones might get it right, showing that there IS a
>>> correct answer.
>>>
>>>>
>>>>>
>>>>> So, you just admitted that you hae just been lying for all these
>>>>> years, and you are no closer to your fantasy goal then you ever were.
>>>>>
>>>>> Sorry, you just don't know enough to do this problem.
>>>>
>>>> I just admitted that it took me about two years to translate my
>>>> intuitions into words that address your objections.
>>>>
>>>> For these two years you and many other people claimed that H1(D,D)
>>>> could not possibly do what it actually did actually do. This has
>>>> always been the same thing as disagreeing with arithmetic.
>>>>
>>>
>>> It can't do it and be the SAME COMPUTATION as H, which is what you
>>> were claiming.
>>>
>>
>> It did actually do exactly what I claimed and everyone wanted
>> to stick to their opinion and deny the actual facts that it
>> did actually do what I said.
>
> It might have done what you THOUGHT you were saying, but it doesn't do
> what you ACTUALLY SAID.
>

I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
always said it was impossible even though that is what actual code
actually did. The code always discloses that H and H1 have their own
address.

u32 H1(ptr P, ptr I)
{ u32 Address_of_H1 = (u32)H1; // 2022-08-15

u32 H(ptr P, ptr I)
{ u32 Address_of_H = (u32)H;

> THe problem is you MISUSED technical terms, because you didn't, and
> apparently still don't, understand what they mean.
>
> Either you have a sever learning disability, or you are just being
> willfully ignorant (or both).
>
> It was clearly asked, and yoyu confirmed, that H and H1 were claimed to
> be the same COMPUTATION,

I never sad anything like that.
I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
always said it was impossible even though that is what actual code
actually did.

> which means they are only a function of there
> declaired inputs, and the exact same algorithm, and neither H nor H1
> take their address as a declared input, but somehow (we know how) manage
> to do different things based on that value.
>
I showed use the execution trace two dozen times and in
each case it was clear that the machines had their own
machine address.


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

<usm5np$3f27j$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory sci.logic
Path: i2pn2.org!i2pn.org!paganini.bofh.team!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_--new_focus--
Date: Mon, 11 Mar 2024 00:44:25 -0500
Organization: A noiseless patient Spider
Lines: 521
Message-ID: <usm5np$3f27j$2@dont-email.me>
References: <usia2e$2f2pd$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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
<usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org>
<usm3eg$3em6b$1@dont-email.me> <usm4id$1enef$24@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 05:44:25 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3639539"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18T0zJKtIaTEg9CPdD6C7ug"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:fqTLIFFIhMF2mVLnoSlPXu0MAn0=
Content-Language: en-US
In-Reply-To: <usm4id$1enef$24@i2pn2.org>
 by: olcott - Mon, 11 Mar 2024 05:44 UTC

On 3/11/2024 12:24 AM, Richard Damon wrote:
> On 3/10/24 10:05 PM, olcott wrote:
>> On 3/10/2024 11:54 PM, Richard Damon wrote:
>>> On 3/10/24 9:38 PM, olcott wrote:
>>>> On 3/10/2024 11:10 PM, Richard Damon wrote:
>>>>> On 3/10/24 8:33 PM, olcott wrote:
>>>>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>>>>> 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>
>>>>>>>>>>>
>>>>>>>>>>> Of course it can abort its simulation.
>>>>>>>>>>>
>>>>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *I have always been using this long before I read about it*
>>>>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>>>>> Two common phenomena characterize BVSR thinking: superfluity
>>>>>>>>>> and backtracking. Superfluity means that the creator generates
>>>>>>>>>> a variety of ideas, one or more of which turn out to be useless.
>>>>>>>>>
>>>>>>>>> But if you have mo idea how things actually works, this seems
>>>>>>>>> to just generate random noise.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Backtracking signifies that the creator must often return to
>>>>>>>>>> an earlier approach after blindly going off in the wrong
>>>>>>>>>> direction.
>>>>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>>>>
>>>>>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>>>>>> simulating* *termination analyzer to the halting problem
>>>>>>>>>> counter-example input*
>>>>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>>>>
>>>>>>>>> Nope, I remember talk of that when I was in college, and they
>>>>>>>>> showed why it can't work.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>  From a programmer's point of view, if we apply an interpreter
>>>>>>>>>> to a
>>>>>>>>>> program text that includes a call to that same interpreter
>>>>>>>>>> with that
>>>>>>>>>> same text as argument, then we have an infinite loop. A
>>>>>>>>>> halting program
>>>>>>>>>> has some of the same character as an interpreter: it applies
>>>>>>>>>> to texts
>>>>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a
>>>>>>>>>> halting
>>>>>>>>>> program to a program text that includes a call to that same
>>>>>>>>>> halting
>>>>>>>>>> program with that same text as argument, then we have an
>>>>>>>>>> infinite loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>>>>
>>>>>>>>> You THINK so, but if the interpreter is a CONDITIONAL
>>>>>>>>> interpreter, that doesn't hold.
>>>>>>>>>
>>>>>>>>> You seem to miss that fact.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *Turing Machine and Olcott machine implementations seem to be
>>>>>>>>>> dead*
>>>>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And the reason it is a dead end is they make it too hard for
>>>>>>>>> you to cheat.
>>>>>>>>>
>>>>>>>>> You need to hide that your H is trying to get in some extra
>>>>>>>>> information to hide that the embedded version of H doesn't give
>>>>>>>>> the same answer, which just shows that your H^ is built wrong.
>>>>>>>>
>>>>>>>> My C code proves these two have different behavior:
>>>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>>>> (b) H(D,D) + H_machine_address
>>>>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>>>>
>>>>>>>> I say:
>>>>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>
>>>>>>>> immibis disagrees.
>>>>>>>> Correct reasoning will show who is correct.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, and since H1 is a different computation than H, it getting
>>>>>>> the right answer doesn't keep H from being broken.
>>>>>>>
>>>>>>> We can then make a D1 to break H1.
>>>>>>>
>>>>>>
>>>>>> I think that immibis already said that and I did not notice
>>>>>> the significance of it at the time.
>>>>>>
>>>>>
>>>>> Of course.
>>>>>
>>>>>> Then we are back to undecidability being incorrectly construed
>>>>>> as an actual limit to computation.
>>>>>
>>>>> Strange definition of not an actual limit if not being able to do
>>>>> something isn't a limit.
>>>>>
>>>>>>
>>>>>> Professor's Hehner and Stoddart have only construed this as
>>>>>> applying to the Halting Problem's pathological input.
>>>>>>
>>>>>> We three perfectly agree on this as it pertains to the
>>>>>> Halting Problem.
>>>>>>
>>>>>> That two full PhD professors of computer science and I all
>>>>>> agree on this shows that I am not a crackpot/crank on this.
>>>>>> I think that all of the other options may now be exhausted.
>>>>>>
>>>>>> I am very happy that I quit tolerating the [change the subject]
>>>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>>>>
>>>>>> *The focus now must be on finding the best words that prove*
>>>>>> *this original position of mine (thus the concurring positions*
>>>>>> *of professors Hehner and Stoddart) is correct*
>>>>>
>>>>> Go knock yourself out on that.
>>>>>
>>>>>>
>>>>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)
>>>>>> sci.logic
>>>>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>>>>  > PREMISES:
>>>>>>  > (1) The Halting Problem was specified in such a way that a
>>>>>> solution
>>>>>>  > was defined to be impossible.
>>>>>
>>>>> Nope.
>>>>>
>>>>> The PROBLEM is the question if a machine can compute the Halting
>>>>> Function.
>>>>>
>>>>> The answer to that, has turned out to be NO.
>>>>>
>>>>> When the problem was first being posed, it was hoped the answer
>>>>> woudl be yes, so it couldn't have bee made specifically to make it
>>>>> impossible.
>>>>>
>>>>>
>>>>> The Halting QUESTION, has an answer for every input that it the
>>>>> description of an actual algorithm applied to an actual data input.
>>>>>
>>>>> Note, Not a "Template" that gets appled to the decider, that IS an
>>>>> invalid question, and impossible to build a description of a Turing
>>>>> Machine to ask that.
>>>>>
>>>>> Thus, when you admitted that your input wasn't actually a
>>>>> description of a program, but just a template, you were admitting
>>>>> that you were lying about working on the Halting Problem, as your
>>>>> input isn't of the right type.
>>>>>
>>>>> Yes, asking about a template IS an invalid question.
>>>>>
>>>>>>  >
>>>>>>  > (2) The set of questions that are defined to not have any possible
>>>>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>>>>  > …
>>>>>
>>>>> And, when you are asking the actual Halting Question, about a
>>>>> specific machine and input, like a SPECIFIC H^, built to foil a
>>>>> SPECIIFIC H, then that input has a specific and definate behavior
>>>>> and there is a specific and definate answer (That depends on the H
>>>>> that you chose to build it on, but not the decider you are asking
>>>>> the question to).
>>>>>
>>>>>>  > CONCLUSION:
>>>>>>  > Therefore the Halting Problem is an ill-formed question.
>>>>>>  >
>>>>>
>>>>> Nope, as explained above. You are just showing that you never
>>>>> understood the actual question or what any of the theory actually
>>>>> means, and have just wasted the last decades of your life on a
>>>>> stupid misconception of your own.
>>>>>
>>>>>> USENET Message-ID:
>>>>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>
>>>>>> *Direct Link to original message*
>>>>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> That YES and NO are the wrong answer for each implementation of
>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
>>>> questions asked of these machine/inputs pairs are incorrect questions.
>>>>
>>>>
>>>>
>>>
>>> Justs shows how must of a stupid idiot you are, because you just
>>> ignored the explaination.
>>>
>>
>> You don't seem to understand that every element of a set that shares
>> common properties all have these same properties in common.
>
> But not if they have different properties.
>
> You don't seem to understand that.
>
>>
>> Does your input halt on its input?
>> is an incorrect question for each Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> WHY?
>
> EACH INDIVIDUAL INPUT HAS A CORRECT ANSWER
>
>>
>> All of the Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that transition to Ĥ.Hqy answer incorrectly.
>
> But there IS a correct answer, non-halting
>
>> All of the Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that transition to Ĥ.Hqn answer incorrectly.
>
> But there IS a correct answer, Halting,
>
> If H (H^) (H^) goes to qy, it can NEVER go to qn for that input and be
> the same machine, so the question about what should we change H to do,
> is just improper.
>
>>
>> Now we run ran out of all of the elements of the infinite set
>> of each possible implementation of Ĥ.H. They all get the wrong
>> answer to this question: Does your input halt on its input?
>
> Right, that makes the question UNCOMPUTABLE, not invalid.
>
> EVERY QUESTION had a right answer (we aren't asking what H should return
> to be right, but what is the right answer, and IS H right)
>
> You are just proving you don't understand the question.
>
> And the problem seems so deep, it is clear you have brainwashed yourself
> so you can't believe (or are just that good of a pathological liar)
>
> This is self-inflicted, as you CHOSE to not learn the terms of the
> field, afraid they would brainwash you into false thought. Instead you
> chose the "supperior" path of going out intentionally ignorant of the
> system and just make mistakes at every turn.
>


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

<usm6p0$1enef$25@i2pn2.org>

  copy mid

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

  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_--new_focus--
Date: Sun, 10 Mar 2024 23:02:07 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usm6p0$1enef$25@i2pn2.org>
References: <usia2e$2f2pd$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>
<usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me>
<lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me>
<uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me>
<usm07p$1enef$21@i2pn2.org> <usm1sg$3ebq5$2@dont-email.me>
<usm2ps$1enef$22@i2pn2.org> <usm3eg$3em6b$1@dont-email.me>
<usm4id$1enef$24@i2pn2.org> <usm5np$3f27j$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 06:02:08 -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: <usm5np$3f27j$2@dont-email.me>
X-Spam-Checker-Version: SpamAssassin 4.0.0
 by: Richard Damon - Mon, 11 Mar 2024 06:02 UTC

On 3/10/24 10:44 PM, olcott wrote:

> *Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>

Yes, you have rotely repeated that many times, not knowing what that
implies, or doesn't imply.

It is also true that every instance of that question has a right answer,
it just isn't the one that H gives.

Thus, the question is VALID but UNCOMPUTABLE.

You are just proving your utter ignorance and inability to learn.

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<usm7mf$1enef$26@i2pn2.org>

  copy mid

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

  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_--RASP_Machines--
Date: Sun, 10 Mar 2024 23:17:50 -0700
Organization: i2pn2 (i2pn.org)
Message-ID: <usm7mf$1enef$26@i2pn2.org>
References: <usia2e$2f2pd$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>
<usl0u7$34bnj$1@dont-email.me> <usljen$385ff$1@dont-email.me>
<hItHN.366352$q3F7.153154@fx45.iad> <uslrcc$3d3q0$1@dont-email.me>
<uslsgn$1enef$20@i2pn2.org> <usm1ib$3ebq5$1@dont-email.me>
<usm3ho$1enef$23@i2pn2.org> <usm5h9$3f27j$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 06:17:51 -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: <usm5h9$3f27j$1@dont-email.me>
Content-Language: en-US
 by: Richard Damon - Mon, 11 Mar 2024 06:17 UTC

On 3/10/24 10:40 PM, olcott wrote:
> On 3/11/2024 12:07 AM, Richard Damon wrote:
>> On 3/10/24 9:33 PM, olcott wrote:
>>> On 3/10/2024 10:07 PM, Richard Damon wrote:
>>>> On 3/10/24 7:47 PM, olcott wrote:
>>>>> On 3/10/2024 9:08 PM, Richard Damon wrote:
>>>>>> On 3/10/24 5:32 PM, olcott wrote:
>>>>>>> On 3/10/2024 2:16 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.
>>>>>>>>
>>>>>>>> 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.
>>>>>>>
>>>>>>> Turing Machines and Olcott machines cannot properly implement
>>>>>>> H1(D,D) and H(D,D) that know their own machine address.
>>>>>>>
>>>>>>> My C code proves these two have different behavior:
>>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>>> (b) H(D,D) + H_machine_address
>>>>>>>
>>>>>>> Because they are different computations they are
>>>>>>> not required to have the same behavior.
>>>>>>
>>>>>> Right, but it also means that since the dfference is because of a
>>>>>> "Hidden" input none of them qualify as a Halt Decider.
>>>>>>
>>>>>
>>>>> The key input (the machines own address) is not hidden
>>>>> merely unavailable to Turing machine and Olcott machines.
>>>>
>>>> And if it isn't hidden, then the other copies that take use a
>>>> different address become different computations and can't claim to
>>>> fill in for THE H.
>>>>
>>>> You then prove each copy wrong by giving it the version of H^/D that
>>>> is built on it, which it will get wrong.
>>>>
>>>> All the other ones might get it right, showing that there IS a
>>>> correct answer.
>>>>
>>>>>
>>>>>>>
>>>>>>> H(D,D) immediately sees the first time it calls itself
>>>>>>> with its same inputs.
>>>>>>>
>>>>>>> H1(D,D) never sees it call itself with its same inputs.
>>>>>>>
>>>>>>> Full Execution trace of H1(D,D)
>>>>>>> (a) main() invokes H1(D,D)
>>>>>>> (b) H1(D,D) simulates D(D)
>>>>>>> (c) Simulated D(D) calls simulated H(D,D)
>>>>>>> (d) Simulated H(D,D) simulates another D(D)
>>>>>>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>>>>>>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>>>>>>> (g) Simulated caller D(D) returns to H1(D,D)
>>>>>>> (h) H1(D,D) returns 1 to main()
>>>>>>>
>>>>>>> They cannot be implemented as Turing Machines or Olcott
>>>>>>> Machines. They can be implemented as RASP machines proven
>>>>>>> by the fact that they are implemented as C functions.
>>>>>>>
>>>>>>
>>>>>> Right, which proves your C functions also were never the required
>>>>>> computation, as they has an extra "hidden" input. As has been told
>>>>>> to you many times in the past.
>>>>>
>>>>> When I specify that every machine can know its own machine address
>>>>> in x86 machines and (possibly augmented) RASP machines then it is
>>>>> not hidden and an explicitly part of the input to the computation.
>>>>
>>>> And if it isn't hidden, then the other copies that take use a
>>>> different address become different computations and can't claim to
>>>> fill in for THE H.
>>>>
>>>> You then prove each copy wrong by giving it the version of H^/D that
>>>> is built on it, which it will get wrong.
>>>>
>>>> All the other ones might get it right, showing that there IS a
>>>> correct answer.
>>>>
>>>>>
>>>>>>
>>>>>> So, you just admitted that you hae just been lying for all these
>>>>>> years, and you are no closer to your fantasy goal then you ever were.
>>>>>>
>>>>>> Sorry, you just don't know enough to do this problem.
>>>>>
>>>>> I just admitted that it took me about two years to translate my
>>>>> intuitions into words that address your objections.
>>>>>
>>>>> For these two years you and many other people claimed that H1(D,D)
>>>>> could not possibly do what it actually did actually do. This has
>>>>> always been the same thing as disagreeing with arithmetic.
>>>>>
>>>>
>>>> It can't do it and be the SAME COMPUTATION as H, which is what you
>>>> were claiming.
>>>>
>>>
>>> It did actually do exactly what I claimed and everyone wanted
>>> to stick to their opinion and deny the actual facts that it
>>> did actually do what I said.
>>
>> It might have done what you THOUGHT you were saying, but it doesn't do
>> what you ACTUALLY SAID.
>>
>
> I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
> always said it was impossible even though that is what actual code
> actually did. The code always discloses that H and H1 have their own
> address.

No, we said it was impossible if they were the COMPUTATIONS you were
claiming them to be.

That was expalined, and you ignored it, so it wasn't an "Honest
Mistake", but a willful disreguard for the truth, and thus a LIE.

You apparently STILL don't understand that term, and seam to prefer just
wasting. you time spinning your wheels on falsehoods, then being willing
to spend justa bit of time to learn the meaning of the basic words of
the thing you are claiming to be making novel discoveries in, that are
just crappy lies.


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

<usmn5q$3ijr4$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --attribution--
Date: Mon, 11 Mar 2024 12:42:02 +0200
Organization: -
Lines: 279
Message-ID: <usmn5q$3ijr4$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3755876"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+ioPHWWIjI8xefg/1Q1Y1s"
User-Agent: Unison/2.2
Cancel-Lock: sha1:TVEeFD3ri3hkO9qozmHwiIY51o4=
 by: Mikko - Mon, 11 Mar 2024 10:42 UTC

On 2024-03-11 02:05:53 +0000, olcott said:

> On 3/10/2024 8:52 PM, Richard Damon wrote:
>> On 3/10/24 6:00 PM, olcott wrote:
>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>> 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>
>>>>
>>>> Of course it can abort its simulation.
>>>>
>>>> It just needs some way to get the right answer.
>>>>
>>>
>>> *I have always been using this long before I read about it*
>>> blind variation and selective retention (BVSR)...
>>> Two common phenomena characterize BVSR thinking: superfluity and
>>> backtracking. Superfluity means that the creator generates a variety of
>>> ideas, one or more of which turn out to be useless.
>>
>> But if you have mo idea how things actually works, this seems to just
>> generate random noise.
>>
>>>
>>> Backtracking signifies that the creator must often return to an earlier
>>> approach after blindly going off in the wrong direction.
>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>
>>> *I am aware of no one else that had the idea to apply a simulating*
>>> *termination analyzer to the halting problem counter-example input*
>>> Professor Hehner had a seed of this idea before I did.
>>
>> Nope, I remember talk of that when I was in college, and they showed
>> why it can't work.
>>
>>>
>>>  From a programmer's point of view, if we apply an interpreter to a
>>> program text that includes a call to that same interpreter with that
>>> same text as argument, then we have an infinite loop. A halting program
>>> has some of the same character as an interpreter: it applies to texts
>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>> program to a program text that includes a call to that same halting
>>> program with that same text as argument, then we have an infinite loop.
>>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>
>> You THINK so, but if the interpreter is a CONDITIONAL interpreter, that
>> doesn't hold.
>>
>> You seem to miss that fact.
>>
>>>
>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>> Every machine must be able to get its own machine address.
>>>
>>
>> And the reason it is a dead end is they make it too hard for you to cheat.
>>
>> You need to hide that your H is trying to get in some extra information
>> to hide that the embedded version of H doesn't give the same answer,
>> which just shows that your H^ is built wrong.
>
> My C code proves these two have different behavior:
> (a) H1(D,D) + H1_machine_address
> (b) H(D,D) + H_machine_address
> H1(D,D) does correctly determine the halt status of D(D) because
> H(D,D) does NOT correctly determine the halt status of D(D).
>
> I say:
> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> immibis disagrees.
> Correct reasoning will show who is correct.


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

<usmncj$3il8v$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --new focus--
Date: Mon, 11 Mar 2024 12:45:39 +0200
Organization: -
Lines: 385
Message-ID: <usmncj$3il8v$1@dont-email.me>
References: <usia2e$2f2pd$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> <usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org> <usm1sg$3ebq5$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3757343"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18UIOFZqYVNMT791JVl4wYP"
User-Agent: Unison/2.2
Cancel-Lock: sha1:vvK4MaU/+MlGqCHt3JIeRiFs2wU=
 by: Mikko - Mon, 11 Mar 2024 10:45 UTC

On 2024-03-11 04:38:40 +0000, olcott said:

> On 3/10/2024 11:10 PM, Richard Damon wrote:
>> On 3/10/24 8:33 PM, olcott wrote:
>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>> 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>
>>>>>>>>
>>>>>>>> Of course it can abort its simulation.
>>>>>>>>
>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>
>>>>>>>
>>>>>>> *I have always been using this long before I read about it*
>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>>>> backtracking. Superfluity means that the creator generates a variety of
>>>>>>> ideas, one or more of which turn out to be useless.
>>>>>>
>>>>>> But if you have mo idea how things actually works, this seems to just
>>>>>> generate random noise.
>>>>>>
>>>>>>>
>>>>>>> Backtracking signifies that the creator must often return to an earlier
>>>>>>> approach after blindly going off in the wrong direction.
>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>
>>>>>>> *I am aware of no one else that had the idea to apply a simulating*
>>>>>>> *termination analyzer to the halting problem counter-example input*
>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>
>>>>>> Nope, I remember talk of that when I was in college, and they showed
>>>>>> why it can't work.
>>>>>>
>>>>>>>
>>>>>>>  From a programmer's point of view, if we apply an interpreter to a
>>>>>>> program text that includes a call to that same interpreter with that
>>>>>>> same text as argument, then we have an infinite loop. A halting program
>>>>>>> has some of the same character as an interpreter: it applies to texts
>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>>>>>> program to a program text that includes a call to that same halting
>>>>>>> program with that same text as argument, then we have an infinite loop.
>>>>>>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>
>>>>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter, that
>>>>>> doesn't hold.
>>>>>>
>>>>>> You seem to miss that fact.
>>>>>>
>>>>>>>
>>>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>
>>>>>>
>>>>>> And the reason it is a dead end is they make it too hard for you to cheat.
>>>>>>
>>>>>> You need to hide that your H is trying to get in some extra information
>>>>>> to hide that the embedded version of H doesn't give the same answer,
>>>>>> which just shows that your H^ is built wrong.
>>>>>
>>>>> My C code proves these two have different behavior:
>>>>> (a) H1(D,D) + H1_machine_address
>>>>> (b) H(D,D) + H_machine_address
>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>
>>>>> I say:
>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>
>>>>> immibis disagrees.
>>>>> Correct reasoning will show who is correct.
>>>>>
>>>>
>>>> Yes, and since H1 is a different computation than H, it getting the
>>>> right answer doesn't keep H from being broken.
>>>>
>>>> We can then make a D1 to break H1.
>>>>
>>>
>>> I think that immibis already said that and I did not notice
>>> the significance of it at the time.
>>>
>>
>> Of course.
>>
>>> Then we are back to undecidability being incorrectly construed
>>> as an actual limit to computation.
>>
>> Strange definition of not an actual limit if not being able to do
>> something isn't a limit.
>>
>>>
>>> Professor's Hehner and Stoddart have only construed this as
>>> applying to the Halting Problem's pathological input.
>>>
>>> We three perfectly agree on this as it pertains to the
>>> Halting Problem.
>>>
>>> That two full PhD professors of computer science and I all
>>> agree on this shows that I am not a crackpot/crank on this.
>>> I think that all of the other options may now be exhausted.
>>>
>>> I am very happy that I quit tolerating the [change the subject]
>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>
>>> *The focus now must be on finding the best words that prove*
>>> *this original position of mine (thus the concurring positions*
>>> *of professors Hehner and Stoddart) is correct*
>>
>> Go knock yourself out on that.
>>
>>>
>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)  sci.logic
>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>  > PREMISES:
>>>  > (1) The Halting Problem was specified in such a way that a solution
>>>  > was defined to be impossible.
>>
>> Nope.
>>
>> The PROBLEM is the question if a machine can compute the Halting Function.
>>
>> The answer to that, has turned out to be NO.
>>
>> When the problem was first being posed, it was hoped the answer woudl
>> be yes, so it couldn't have bee made specifically to make it impossible.
>>
>>
>> The Halting QUESTION, has an answer for every input that it the
>> description of an actual algorithm applied to an actual data input.
>>
>> Note, Not a "Template" that gets appled to the decider, that IS an
>> invalid question, and impossible to build a description of a Turing
>> Machine to ask that.
>>
>> Thus, when you admitted that your input wasn't actually a description
>> of a program, but just a template, you were admitting that you were
>> lying about working on the Halting Problem, as your input isn't of the
>> right type.
>>
>> Yes, asking about a template IS an invalid question.
>>
>>>  >
>>>  > (2) The set of questions that are defined to not have any possible
>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>  > …
>>
>> And, when you are asking the actual Halting Question, about a specific
>> machine and input, like a SPECIFIC H^, built to foil a SPECIIFIC H,
>> then that input has a specific and definate behavior and there is a
>> specific and definate answer (That depends on the H that you chose to
>> build it on, but not the decider you are asking the question to).
>>
>>>  > CONCLUSION:
>>>  > Therefore the Halting Problem is an ill-formed question.
>>>  >
>>
>> Nope, as explained above. You are just showing that you never
>> understood the actual question or what any of the theory actually
>> means, and have just wasted the last decades of your life on a stupid
>> misconception of your own.
>>
>>> USENET Message-ID:
>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>
>>> *Direct Link to original message*
>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> That YES and NO are the wrong answer for each implementation of
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
> questions asked of these machine/inputs pairs are incorrect questions.


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

<usmnka$3imd4$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --new focus--
Date: Mon, 11 Mar 2024 12:49:46 +0200
Organization: -
Lines: 12
Message-ID: <usmnka$3imd4$1@dont-email.me>
References: <usia2e$2f2pd$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> <usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org> <usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org> <usm3eg$3em6b$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3758500"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/ECfbD6mA2Mcf2GBJtCxlW"
User-Agent: Unison/2.2
Cancel-Lock: sha1:xrl+9lYzeVaSNoH7rcbQJerZa4o=
 by: Mikko - Mon, 11 Mar 2024 10:49 UTC

On 2024-03-11 05:05:19 +0000, olcott said:

> Does your input halt on its input?
> is an incorrect question for each Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

It is incorrect in sthe sense that it is not the question
asked in the halting problem. Otherwise it can be a reasonable
question.

--
Mikko

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

<usmnq5$3io83$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC --new focus--
Date: Mon, 11 Mar 2024 12:52:53 +0200
Organization: -
Lines: 448
Message-ID: <usmnq5$3io83$1@dont-email.me>
References: <usia2e$2f2pd$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> <usl1c7$1enef$9@i2pn2.org> <usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad> <uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org> <uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org> <usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org> <usm3eg$3em6b$1@dont-email.me> <usm4id$1enef$24@i2pn2.org> <usm5np$3f27j$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3760387"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/XbSaqtPi7+egJwNivqcmL"
User-Agent: Unison/2.2
Cancel-Lock: sha1:uSi5WxHwN5+bFOaWoqNcB4Xq6BU=
 by: Mikko - Mon, 11 Mar 2024 10:52 UTC

On 2024-03-11 05:44:25 +0000, olcott said:

> On 3/11/2024 12:24 AM, Richard Damon wrote:
>> On 3/10/24 10:05 PM, olcott wrote:
>>> On 3/10/2024 11:54 PM, Richard Damon wrote:
>>>> On 3/10/24 9:38 PM, olcott wrote:
>>>>> On 3/10/2024 11:10 PM, Richard Damon wrote:
>>>>>> On 3/10/24 8:33 PM, olcott wrote:
>>>>>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>>>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>> 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>
>>>>>>>>>>>>
>>>>>>>>>>>> Of course it can abort its simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *I have always been using this long before I read about it*
>>>>>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>>>>>>>> backtracking. Superfluity means that the creator generates a variety of
>>>>>>>>>>> ideas, one or more of which turn out to be useless.
>>>>>>>>>>
>>>>>>>>>> But if you have mo idea how things actually works, this seems to just
>>>>>>>>>> generate random noise.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Backtracking signifies that the creator must often return to an earlier
>>>>>>>>>>> approach after blindly going off in the wrong direction.
>>>>>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>>>>>
>>>>>>>>>>> *I am aware of no one else that had the idea to apply a simulating*
>>>>>>>>>>> *termination analyzer to the halting problem counter-example input*
>>>>>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>>>>>
>>>>>>>>>> Nope, I remember talk of that when I was in college, and they showed
>>>>>>>>>> why it can't work.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>  From a programmer's point of view, if we apply an interpreter to a
>>>>>>>>>>> program text that includes a call to that same interpreter with that
>>>>>>>>>>> same text as argument, then we have an infinite loop. A halting program
>>>>>>>>>>> has some of the same character as an interpreter: it applies to texts
>>>>>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>>>>>>>>>> program to a program text that includes a call to that same halting
>>>>>>>>>>> program with that same text as argument, then we have an infinite loop.
>>>>>>>>>>> https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>>>>>
>>>>>>>>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter, that
>>>>>>>>>> doesn't hold.
>>>>>>>>>>
>>>>>>>>>> You seem to miss that fact.
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And the reason it is a dead end is they make it too hard for you to cheat.
>>>>>>>>>>
>>>>>>>>>> You need to hide that your H is trying to get in some extra information
>>>>>>>>>> to hide that the embedded version of H doesn't give the same answer,
>>>>>>>>>> which just shows that your H^ is built wrong.
>>>>>>>>>
>>>>>>>>> My C code proves these two have different behavior:
>>>>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>>>>> (b) H(D,D) + H_machine_address
>>>>>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>>>>>
>>>>>>>>> I say:
>>>>>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>
>>>>>>>>> immibis disagrees.
>>>>>>>>> Correct reasoning will show who is correct.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, and since H1 is a different computation than H, it getting the
>>>>>>>> right answer doesn't keep H from being broken.
>>>>>>>>
>>>>>>>> We can then make a D1 to break H1.
>>>>>>>>
>>>>>>>
>>>>>>> I think that immibis already said that and I did not notice
>>>>>>> the significance of it at the time.
>>>>>>>
>>>>>>
>>>>>> Of course.
>>>>>>
>>>>>>> Then we are back to undecidability being incorrectly construed
>>>>>>> as an actual limit to computation.
>>>>>>
>>>>>> Strange definition of not an actual limit if not being able to do
>>>>>> something isn't a limit.
>>>>>>
>>>>>>>
>>>>>>> Professor's Hehner and Stoddart have only construed this as
>>>>>>> applying to the Halting Problem's pathological input.
>>>>>>>
>>>>>>> We three perfectly agree on this as it pertains to the
>>>>>>> Halting Problem.
>>>>>>>
>>>>>>> That two full PhD professors of computer science and I all
>>>>>>> agree on this shows that I am not a crackpot/crank on this.
>>>>>>> I think that all of the other options may now be exhausted.
>>>>>>>
>>>>>>> I am very happy that I quit tolerating the [change the subject]
>>>>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>>>>>
>>>>>>> *The focus now must be on finding the best words that prove*
>>>>>>> *this original position of mine (thus the concurring positions*
>>>>>>> *of professors Hehner and Stoddart) is correct*
>>>>>>
>>>>>> Go knock yourself out on that.
>>>>>>
>>>>>>>
>>>>>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO) sci.logic
>>>>>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>>>>>  > PREMISES:
>>>>>>>  > (1) The Halting Problem was specified in such a way that a solution
>>>>>>>  > was defined to be impossible.
>>>>>>
>>>>>> Nope.
>>>>>>
>>>>>> The PROBLEM is the question if a machine can compute the Halting Function.
>>>>>>
>>>>>> The answer to that, has turned out to be NO.
>>>>>>
>>>>>> When the problem was first being posed, it was hoped the answer woudl
>>>>>> be yes, so it couldn't have bee made specifically to make it impossible.
>>>>>>
>>>>>>
>>>>>> The Halting QUESTION, has an answer for every input that it the
>>>>>> description of an actual algorithm applied to an actual data input.
>>>>>>
>>>>>> Note, Not a "Template" that gets appled to the decider, that IS an
>>>>>> invalid question, and impossible to build a description of a Turing
>>>>>> Machine to ask that.
>>>>>>
>>>>>> Thus, when you admitted that your input wasn't actually a description
>>>>>> of a program, but just a template, you were admitting that you were
>>>>>> lying about working on the Halting Problem, as your input isn't of the
>>>>>> right type.
>>>>>>
>>>>>> Yes, asking about a template IS an invalid question.
>>>>>>
>>>>>>>  >
>>>>>>>  > (2) The set of questions that are defined to not have any possible
>>>>>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>>>>>  > …
>>>>>>
>>>>>> And, when you are asking the actual Halting Question, about a specific
>>>>>> machine and input, like a SPECIFIC H^, built to foil a SPECIIFIC H,
>>>>>> then that input has a specific and definate behavior and there is a
>>>>>> specific and definate answer (That depends on the H that you chose to
>>>>>> build it on, but not the decider you are asking the question to).
>>>>>>
>>>>>>>  > CONCLUSION:
>>>>>>>  > Therefore the Halting Problem is an ill-formed question.
>>>>>>>  >
>>>>>>
>>>>>> Nope, as explained above. You are just showing that you never
>>>>>> understood the actual question or what any of the theory actually
>>>>>> means, and have just wasted the last decades of your life on a stupid
>>>>>> misconception of your own.
>>>>>>
>>>>>>> USENET Message-ID:
>>>>>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>
>>>>>>> *Direct Link to original message*
>>>>>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> That YES and NO are the wrong answer for each implementation of
>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
>>>>> questions asked of these machine/inputs pairs are incorrect questions.
>>>>>
>>>>>
>>>>>
>>>>
>>>> Justs shows how must of a stupid idiot you are, because you just
>>>> ignored the explaination.
>>>>
>>>
>>> You don't seem to understand that every element of a set that shares
>>> common properties all have these same properties in common.
>>
>> But not if they have different properties.
>>
>> You don't seem to understand that.
>>
>>>
>>> Does your input halt on its input?
>>> is an incorrect question for each Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> WHY?
>>
>> EACH INDIVIDUAL INPUT HAS A CORRECT ANSWER
>>
>>>
>>> All of the Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that transition to Ĥ.Hqy answer incorrectly.
>>
>> But there IS a correct answer, non-halting
>>
>>> All of the Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that transition to Ĥ.Hqn answer incorrectly.
>>
>> But there IS a correct answer, Halting,
>>
>> If H (H^) (H^) goes to qy, it can NEVER go to qn for that input and be
>> the same machine, so the question about what should we change H to do,
>> is just improper.
>>
>>>
>>> Now we run ran out of all of the elements of the infinite set
>>> of each possible implementation of Ĥ.H. They all get the wrong
>>> answer to this question: Does your input halt on its input?
>>
>> Right, that makes the question UNCOMPUTABLE, not invalid.
>>
>> EVERY QUESTION had a right answer (we aren't asking what H should
>> return to be right, but what is the right answer, and IS H right)
>>
>> You are just proving you don't understand the question.
>>
>> And the problem seems so deep, it is clear you have brainwashed
>> yourself so you can't believe (or are just that good of a pathological
>> liar)
>>
>> This is self-inflicted, as you CHOSE to not learn the terms of the
>> field, afraid they would brainwash you into false thought. Instead you
>> chose the "supperior" path of going out intentionally ignorant of the
>> system and just make mistakes at every turn.
>>
>
> *Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*


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

<usmo12$3io83$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC
Date: Mon, 11 Mar 2024 12:56:34 +0200
Organization: -
Lines: 59
Message-ID: <usmo12$3io83$2@dont-email.me>
References: <usia2e$2f2pd$1@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> <usljui$385q4$2@dont-email.me> <uslmh7$38jtu$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3760387"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+OEqkRfmF5eGNdJTO+83M4"
User-Agent: Unison/2.2
Cancel-Lock: sha1:a0+pW7W/QAMbaHtt0HC94aWpo0E=
 by: Mikko - Mon, 11 Mar 2024 10:56 UTC

On 2024-03-11 01:24:55 +0000, olcott said:

> On 3/10/2024 7:40 PM, immibis wrote:
>> On 10/03/24 20:16, 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.
>>
>> And now we are back to: Every Turing machine and input pair defines an
>> execution sequence. Every sequence is either finite or infinite.
>> Therefore it is well-defined and there is no paradox.
>>
>> Can you show me a Turing machine that specifies a sequence of
>> configurations that is not finite or infinite?
>
> When we construe every yes/no question that cannot possibly
> have a correct yes/no answer as an incorrect question
>
> then we must correspondingly construe every decider/input
> pair that has no correct yes/no answer as invalid input.

Apparently the answer is "no" as no such Turing machine is shown
or mentioned above.

--
Mikko

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

<usmoil$3it71$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC
Date: Mon, 11 Mar 2024 13:05:57 +0200
Organization: -
Lines: 105
Message-ID: <usmoil$3it71$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usljui$385q4$2@dont-email.me> <uslmh7$38jtu$2@dont-email.me> <IEtHN.366351$q3F7.176464@fx45.iad> <uslqr6$3d3q7$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3765473"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+mlGBwWrOQev41+BBwoL6a"
User-Agent: Unison/2.2
Cancel-Lock: sha1:5HpgBDccuSe9n77Um2hJxANjCGY=
 by: Mikko - Mon, 11 Mar 2024 11:05 UTC

On 2024-03-11 02:38:30 +0000, olcott said:

> On 3/10/2024 9:04 PM, Richard Damon wrote:
>> On 3/10/24 6:24 PM, olcott wrote:
>>> On 3/10/2024 7:40 PM, immibis wrote:
>>>> On 10/03/24 20:16, 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.
>>>>
>>>> And now we are back to: Every Turing machine and input pair defines an
>>>> execution sequence. Every sequence is either finite or infinite.
>>>> Therefore it is well-defined and there is no paradox.
>>>>
>>>> Can you show me a Turing machine that specifies a sequence of
>>>> configurations that is not finite or infinite?
>>>
>>> When we construe every yes/no question that cannot possibly
>>> have a correct yes/no answer as an incorrect question
>>>
>>> then we must correspondingly construe every decider/input
>>> pair that has no correct yes/no answer as invalid input.
>>>
>>
>> And when you remember that when we posse that ACTUAL question, the
>> input is a FIXED machine, (not a template that changes by the decide
>> that it trying to decide it) then there are a LOT of machines that get
>> the right answer. The key is we know that there is ONE that doesn't,
>> the one that particular decider was built to foil. Thus, the problem
>> isn't an invalid question.
>
>
> In computability theory and computational complexity theory,
> an undecidable problem is a decision problem for which it is
> proved to be impossible to construct an algorithm that always
> leads to a correct yes-or-no answer.
> https://en.wikipedia.org/wiki/Undecidable_problem
>
> If the only reason that a machine does not get a correct yes/no answer
> for this machine/input pair is that both yes and no are the wrong answer
> for this machine/input pair then this machine/input pair is a yes/no
> question that has no correct yes/no answer for this machine/input pair.
>
> The exact same word-for-word question:
> Are you a little girl?
> Has a different meaning depending on who is asked.

It is semantically different question as the meaning of "you" varies.
Teh interpretations of "little" and "girl" may vary, too.

> The exact same word-for-word question:
> Does your input halt on its input?
> Has a different meaning depending on who is asked.

Likewise, because of "you". Also depens on when it is asked
if the input is replaced. And can be an incorrect question
if the input or the input of the input does not exist or
the input is something that cannot be said to "halt" (e.g.,
a number).

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> When every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is asked this question:
> Does your input halt on its input?
> It is an incorrect question.

Yes, so no need say anything about it. A correct question
is "Does Ĥ ⟨Ĥ⟩ halt?".

--
Mikko

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

<usmors$3ivk7$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC
Date: Mon, 11 Mar 2024 13:10:52 +0200
Organization: -
Lines: 44
Message-ID: <usmors$3ivk7$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> <usl0u7$34bnj$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3767943"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+ySXSNhv0VULrpJfgPcpaE"
User-Agent: Unison/2.2
Cancel-Lock: sha1:6DaB+3Lm5yBiSgxhKiZOK7afvRw=
 by: Mikko - Mon, 11 Mar 2024 11:10 UTC

On 2024-03-10 19:16:23 +0000, immibis said:

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

Didn't you notice that he explainned his method, which we may call
"bullshit and backtrack".

--
Mikko

Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--

<usmp2f$3j0jb$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior --RASP Machines--
Date: Mon, 11 Mar 2024 13:14:23 +0200
Organization: -
Lines: 64
Message-ID: <usmp2f$3j0jb$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl0u7$34bnj$1@dont-email.me> <usljen$385ff$1@dont-email.me> <hItHN.366352$q3F7.153154@fx45.iad> <uslrcc$3d3q0$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3768939"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/JYwxzoRKZ6R/FHTs9YlJ0"
User-Agent: Unison/2.2
Cancel-Lock: sha1:GOnzJObwQ8mqW4UTF6hClwSliL0=
 by: Mikko - Mon, 11 Mar 2024 11:14 UTC

On 2024-03-11 02:47:40 +0000, olcott said:

> On 3/10/2024 9:08 PM, Richard Damon wrote:
>> On 3/10/24 5:32 PM, olcott wrote:
>>> On 3/10/2024 2:16 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.
>>>>
>>>> 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.
>>>
>>> Turing Machines and Olcott machines cannot properly implement
>>> H1(D,D) and H(D,D) that know their own machine address.
>>>
>>> My C code proves these two have different behavior:
>>> (a) H1(D,D) + H1_machine_address
>>> (b) H(D,D) + H_machine_address
>>>
>>> Because they are different computations they are
>>> not required to have the same behavior.
>>
>> Right, but it also means that since the dfference is because of a
>> "Hidden" input none of them qualify as a Halt Decider.
>>
>
> The key input (the machines own address) is not hidden
> merely unavailable to Turing machine and Olcott machines.

The main point is that the additional input is not one
of the inputs permitted by tbe halting problem.

--
Mikko

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

<usmpde$3j2lk$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: mikko.levanto@iki.fi (Mikko)
Newsgroups: comp.theory
Subject: Re: Verified fact that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ have different behavior ZFC
Date: Mon, 11 Mar 2024 13:20:15 +0200
Organization: -
Lines: 17
Message-ID: <usmpde$3j2lk$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>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: dont-email.me; posting-host="a877b6d0e708ae371ef12679c3d7479c";
logging-data="3771060"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+trXzFHnUOdqornkY8JE22"
User-Agent: Unison/2.2
Cancel-Lock: sha1:RCviion9MA9VsxbILGl/08oBt+k=
 by: Mikko - Mon, 11 Mar 2024 11:20 UTC

On 2024-03-10 18:07:14 +0000, immibis said:

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

It doesn't matter much whther the determination of the need to abort
is correct or not. Either way, the after that determination and aborting,
the answer H gives is (for at least one input) wrong.

--
Mikko

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

<usn0d2$3klcn$1@dont-email.me>

  copy mid

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

  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_--new_focus--
Date: Mon, 11 Mar 2024 08:19:29 -0500
Organization: A noiseless patient Spider
Lines: 54
Message-ID: <usn0d2$3klcn$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
<usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org>
<usm3eg$3em6b$1@dont-email.me> <usm4id$1enef$24@i2pn2.org>
<usm5np$3f27j$2@dont-email.me> <usm6p0$1enef$25@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 13:19:30 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3822999"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19hvhutCOP8/NgsWJa1Yl6V"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:HXnuprMGxQNSkYbCpLLapi3YWV4=
In-Reply-To: <usm6p0$1enef$25@i2pn2.org>
Content-Language: en-US
 by: olcott - Mon, 11 Mar 2024 13:19 UTC

On 3/11/2024 1:02 AM, Richard Damon wrote:
> On 3/10/24 10:44 PM, olcott wrote:
>
>> *Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>
> Yes, you have rotely repeated that many times, not knowing what that
> implies, or doesn't imply.
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*

> It is also true that every instance of that question has a right answer,
> it just isn't the one that H gives.
>

Every decision problem that includes undecidable instances only has
these instances because there is something wrong with the decision
problem specification.

The proof of the halting problem assumes a universal halt
test exists and then provides S as an example of a program
that the test cannot handle. But S is not a program at all.
It is not even a conceptual object, and this is due to
inconsistencies in the specification of the halting function.
(Stoddart: 2017)

*This is my unique contribution to the field of the Halting Problem*
*This is my unique contribution to the field of the Halting Problem*
*This is my unique contribution to the field of the Halting Problem*

When we ask H ⟨Ĥ⟩ ⟨Ĥ⟩:
Does your input halt on its input?
meaning: Would Ĥ ⟨Ĥ⟩ halt on its input, then H gets the wrong answer.

When we ask the exact same question meaning:
Will you halt if you never abort your simulation?
Then every H always gets the right answer.

> Thus, the question is VALID but UNCOMPUTABLE.
>
> You are just proving your utter ignorance and inability to learn.

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

<usn49b$3lhv0$1@dont-email.me>

  copy mid

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

  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_--Foundations--
Date: Mon, 11 Mar 2024 09:25:46 -0500
Organization: A noiseless patient Spider
Lines: 438
Message-ID: <usn49b$3lhv0$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl0u7$34bnj$1@dont-email.me>
<usljen$385ff$1@dont-email.me> <hItHN.366352$q3F7.153154@fx45.iad>
<uslrcc$3d3q0$1@dont-email.me> <uslsgn$1enef$20@i2pn2.org>
<usm1ib$3ebq5$1@dont-email.me> <usm3ho$1enef$23@i2pn2.org>
<usm5h9$3f27j$1@dont-email.me> <usm7mf$1enef$26@i2pn2.org>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 14:25:47 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3852256"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18CAciZELkOHFVGyBGOnfG0"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:zoS2cN64tYIIGw0E+1F/Q/dDN18=
In-Reply-To: <usm7mf$1enef$26@i2pn2.org>
Content-Language: en-US
 by: olcott - Mon, 11 Mar 2024 14:25 UTC

On 3/11/2024 1:17 AM, Richard Damon wrote:
> On 3/10/24 10:40 PM, olcott wrote:
>> On 3/11/2024 12:07 AM, Richard Damon wrote:
>>> On 3/10/24 9:33 PM, olcott wrote:
>>>> On 3/10/2024 10:07 PM, Richard Damon wrote:
>>>>> On 3/10/24 7:47 PM, olcott wrote:
>>>>>> On 3/10/2024 9:08 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 5:32 PM, olcott wrote:
>>>>>>>> On 3/10/2024 2:16 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.
>>>>>>>>>
>>>>>>>>> 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.
>>>>>>>>
>>>>>>>> Turing Machines and Olcott machines cannot properly implement
>>>>>>>> H1(D,D) and H(D,D) that know their own machine address.
>>>>>>>>
>>>>>>>> My C code proves these two have different behavior:
>>>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>>>> (b) H(D,D) + H_machine_address
>>>>>>>>
>>>>>>>> Because they are different computations they are
>>>>>>>> not required to have the same behavior.
>>>>>>>
>>>>>>> Right, but it also means that since the dfference is because of a
>>>>>>> "Hidden" input none of them qualify as a Halt Decider.
>>>>>>>
>>>>>>
>>>>>> The key input (the machines own address) is not hidden
>>>>>> merely unavailable to Turing machine and Olcott machines.
>>>>>
>>>>> And if it isn't hidden, then the other copies that take use a
>>>>> different address become different computations and can't claim to
>>>>> fill in for THE H.
>>>>>
>>>>> You then prove each copy wrong by giving it the version of H^/D
>>>>> that is built on it, which it will get wrong.
>>>>>
>>>>> All the other ones might get it right, showing that there IS a
>>>>> correct answer.
>>>>>
>>>>>>
>>>>>>>>
>>>>>>>> H(D,D) immediately sees the first time it calls itself
>>>>>>>> with its same inputs.
>>>>>>>>
>>>>>>>> H1(D,D) never sees it call itself with its same inputs.
>>>>>>>>
>>>>>>>> Full Execution trace of H1(D,D)
>>>>>>>> (a) main() invokes H1(D,D)
>>>>>>>> (b) H1(D,D) simulates D(D)
>>>>>>>> (c) Simulated D(D) calls simulated H(D,D)
>>>>>>>> (d) Simulated H(D,D) simulates another D(D)
>>>>>>>> (e) Simulated H(D,D) aborts this D(D) when it would call itself
>>>>>>>> (f) Simulated H(D,D) returns 0 to simulated caller D(D)
>>>>>>>> (g) Simulated caller D(D) returns to H1(D,D)
>>>>>>>> (h) H1(D,D) returns 1 to main()
>>>>>>>>
>>>>>>>> They cannot be implemented as Turing Machines or Olcott
>>>>>>>> Machines. They can be implemented as RASP machines proven
>>>>>>>> by the fact that they are implemented as C functions.
>>>>>>>>
>>>>>>>
>>>>>>> Right, which proves your C functions also were never the required
>>>>>>> computation, as they has an extra "hidden" input. As has been
>>>>>>> told to you many times in the past.
>>>>>>
>>>>>> When I specify that every machine can know its own machine address
>>>>>> in x86 machines and (possibly augmented) RASP machines then it is
>>>>>> not hidden and an explicitly part of the input to the computation.
>>>>>
>>>>> And if it isn't hidden, then the other copies that take use a
>>>>> different address become different computations and can't claim to
>>>>> fill in for THE H.
>>>>>
>>>>> You then prove each copy wrong by giving it the version of H^/D
>>>>> that is built on it, which it will get wrong.
>>>>>
>>>>> All the other ones might get it right, showing that there IS a
>>>>> correct answer.
>>>>>
>>>>>>
>>>>>>>
>>>>>>> So, you just admitted that you hae just been lying for all these
>>>>>>> years, and you are no closer to your fantasy goal then you ever
>>>>>>> were.
>>>>>>>
>>>>>>> Sorry, you just don't know enough to do this problem.
>>>>>>
>>>>>> I just admitted that it took me about two years to translate my
>>>>>> intuitions into words that address your objections.
>>>>>>
>>>>>> For these two years you and many other people claimed that H1(D,D)
>>>>>> could not possibly do what it actually did actually do. This has
>>>>>> always been the same thing as disagreeing with arithmetic.
>>>>>>
>>>>>
>>>>> It can't do it and be the SAME COMPUTATION as H, which is what you
>>>>> were claiming.
>>>>>
>>>>
>>>> It did actually do exactly what I claimed and everyone wanted
>>>> to stick to their opinion and deny the actual facts that it
>>>> did actually do what I said.
>>>
>>> It might have done what you THOUGHT you were saying, but it doesn't
>>> do what you ACTUALLY SAID.
>>>
>>
>> I always claimed that H1(D,D) returns 1 and H(D,D) returns 0 and you
>> always said it was impossible even though that is what actual code
>> actually did. The code always discloses that H and H1 have their own
>> address.
>
> No, we said it was impossible if they were the COMPUTATIONS you were
> claiming them to be.
>


Click here to read the complete article
When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior it actually sees then it is correct

<usn58m$3li08$3@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
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
Subject: When H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the be
havior_it_actually_sees_then_it_is_correct
Date: Mon, 11 Mar 2024 09:42:30 -0500
Organization: A noiseless patient Spider
Lines: 342
Message-ID: <usn58m$3li08$3@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <usmn5q$3ijr4$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 14:42:30 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3852296"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+XUTY8HCftymGoYrfhBNZr"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:QcErG1w5yFOid0xDNvYfTLejkRw=
Content-Language: en-US
In-Reply-To: <usmn5q$3ijr4$1@dont-email.me>
 by: olcott - Mon, 11 Mar 2024 14:42 UTC

On 3/11/2024 5:42 AM, Mikko wrote:
> On 2024-03-11 02:05:53 +0000, olcott said:
>
>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>> On 3/10/24 6:00 PM, olcott wrote:
>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>> 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>
>>>>>
>>>>> Of course it can abort its simulation.
>>>>>
>>>>> It just needs some way to get the right answer.
>>>>>
>>>>
>>>> *I have always been using this long before I read about it*
>>>> blind variation and selective retention (BVSR)...
>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>> backtracking. Superfluity means that the creator generates a variety
>>>> of ideas, one or more of which turn out to be useless.
>>>
>>> But if you have mo idea how things actually works, this seems to just
>>> generate random noise.
>>>
>>>>
>>>> Backtracking signifies that the creator must often return to an
>>>> earlier approach after blindly going off in the wrong direction.
>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>
>>>> *I am aware of no one else that had the idea to apply a simulating*
>>>> *termination analyzer to the halting problem counter-example input*
>>>> Professor Hehner had a seed of this idea before I did.
>>>
>>> Nope, I remember talk of that when I was in college, and they showed
>>> why it can't work.
>>>
>>>>
>>>>  From a programmer's point of view, if we apply an interpreter to a
>>>> program text that includes a call to that same interpreter with that
>>>> same text as argument, then we have an infinite loop. A halting program
>>>> has some of the same character as an interpreter: it applies to texts
>>>> through abstract interpretation. Unsurprisingly, if we apply a halting
>>>> program to a program text that includes a call to that same halting
>>>> program with that same text as argument, then we have an infinite
>>>> loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>
>>> You THINK so, but if the interpreter is a CONDITIONAL interpreter,
>>> that doesn't hold.
>>>
>>> You seem to miss that fact.
>>>
>>>>
>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>> Every machine must be able to get its own machine address.
>>>>
>>>
>>> And the reason it is a dead end is they make it too hard for you to
>>> cheat.
>>>
>>> You need to hide that your H is trying to get in some extra
>>> information to hide that the embedded version of H doesn't give the
>>> same answer, which just shows that your H^ is built wrong.
>>
>> My C code proves these two have different behavior:
>> (a) H1(D,D) + H1_machine_address
>> (b) H(D,D) + H_machine_address
>> H1(D,D) does correctly determine the halt status of D(D) because
>> H(D,D) does NOT correctly determine the halt status of D(D).
>>
>> I say:
>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> immibis disagrees.
>> Correct reasoning will show who is correct.
>
> As H does not correctly determine the halt status of D(D) and
> H1 does not correctly determine the halt status of D1(D1) neither
> of them is a halt decider.
>


Click here to read the complete article
H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

<usn5vc$3ltjo$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
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
Subject: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when report
s_on_the_actual_behavior_that_it_sees
Date: Mon, 11 Mar 2024 09:54:34 -0500
Organization: A noiseless patient Spider
Lines: 468
Message-ID: <usn5vc$3ltjo$1@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
<usm1sg$3ebq5$2@dont-email.me> <usmncj$3il8v$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 14:54:36 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3864184"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX198fLlWcrtF/QsVP4WDMQrx"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:H9P6F0hE5I+VGGgSFIRYtHHflcA=
Content-Language: en-US
In-Reply-To: <usmncj$3il8v$1@dont-email.me>
 by: olcott - Mon, 11 Mar 2024 14:54 UTC

On 3/11/2024 5:45 AM, Mikko wrote:
> On 2024-03-11 04:38:40 +0000, olcott said:
>
>> On 3/10/2024 11:10 PM, Richard Damon wrote:
>>> On 3/10/24 8:33 PM, olcott wrote:
>>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>>> 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>
>>>>>>>>>
>>>>>>>>> Of course it can abort its simulation.
>>>>>>>>>
>>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *I have always been using this long before I read about it*
>>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>>> Two common phenomena characterize BVSR thinking: superfluity and
>>>>>>>> backtracking. Superfluity means that the creator generates a
>>>>>>>> variety of ideas, one or more of which turn out to be useless.
>>>>>>>
>>>>>>> But if you have mo idea how things actually works, this seems to
>>>>>>> just generate random noise.
>>>>>>>
>>>>>>>>
>>>>>>>> Backtracking signifies that the creator must often return to an
>>>>>>>> earlier approach after blindly going off in the wrong direction.
>>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>>
>>>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>>>> simulating* *termination analyzer to the halting problem
>>>>>>>> counter-example input*
>>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>>
>>>>>>> Nope, I remember talk of that when I was in college, and they
>>>>>>> showed why it can't work.
>>>>>>>
>>>>>>>>
>>>>>>>>  From a programmer's point of view, if we apply an interpreter to a
>>>>>>>> program text that includes a call to that same interpreter with
>>>>>>>> that
>>>>>>>> same text as argument, then we have an infinite loop. A halting
>>>>>>>> program
>>>>>>>> has some of the same character as an interpreter: it applies to
>>>>>>>> texts
>>>>>>>> through abstract interpretation. Unsurprisingly, if we apply a
>>>>>>>> halting
>>>>>>>> program to a program text that includes a call to that same halting
>>>>>>>> program with that same text as argument, then we have an
>>>>>>>> infinite loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>>
>>>>>>> You THINK so, but if the interpreter is a CONDITIONAL
>>>>>>> interpreter, that doesn't hold.
>>>>>>>
>>>>>>> You seem to miss that fact.
>>>>>>>
>>>>>>>>
>>>>>>>> *Turing Machine and Olcott machine implementations seem to be dead*
>>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>>
>>>>>>>
>>>>>>> And the reason it is a dead end is they make it too hard for you
>>>>>>> to cheat.
>>>>>>>
>>>>>>> You need to hide that your H is trying to get in some extra
>>>>>>> information to hide that the embedded version of H doesn't give
>>>>>>> the same answer, which just shows that your H^ is built wrong.
>>>>>>
>>>>>> My C code proves these two have different behavior:
>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>> (b) H(D,D) + H_machine_address
>>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>>
>>>>>> I say:
>>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>
>>>>>> immibis disagrees.
>>>>>> Correct reasoning will show who is correct.
>>>>>>
>>>>>
>>>>> Yes, and since H1 is a different computation than H, it getting the
>>>>> right answer doesn't keep H from being broken.
>>>>>
>>>>> We can then make a D1 to break H1.
>>>>>
>>>>
>>>> I think that immibis already said that and I did not notice
>>>> the significance of it at the time.
>>>>
>>>
>>> Of course.
>>>
>>>> Then we are back to undecidability being incorrectly construed
>>>> as an actual limit to computation.
>>>
>>> Strange definition of not an actual limit if not being able to do
>>> something isn't a limit.
>>>
>>>>
>>>> Professor's Hehner and Stoddart have only construed this as
>>>> applying to the Halting Problem's pathological input.
>>>>
>>>> We three perfectly agree on this as it pertains to the
>>>> Halting Problem.
>>>>
>>>> That two full PhD professors of computer science and I all
>>>> agree on this shows that I am not a crackpot/crank on this.
>>>> I think that all of the other options may now be exhausted.
>>>>
>>>> I am very happy that I quit tolerating the [change the subject]
>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>>
>>>> *The focus now must be on finding the best words that prove*
>>>> *this original position of mine (thus the concurring positions*
>>>> *of professors Hehner and Stoddart) is correct*
>>>
>>> Go knock yourself out on that.
>>>
>>>>
>>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)
>>>> sci.logic
>>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>>  > PREMISES:
>>>>  > (1) The Halting Problem was specified in such a way that a solution
>>>>  > was defined to be impossible.
>>>
>>> Nope.
>>>
>>> The PROBLEM is the question if a machine can compute the Halting
>>> Function.
>>>
>>> The answer to that, has turned out to be NO.
>>>
>>> When the problem was first being posed, it was hoped the answer woudl
>>> be yes, so it couldn't have bee made specifically to make it impossible.
>>>
>>>
>>> The Halting QUESTION, has an answer for every input that it the
>>> description of an actual algorithm applied to an actual data input.
>>>
>>> Note, Not a "Template" that gets appled to the decider, that IS an
>>> invalid question, and impossible to build a description of a Turing
>>> Machine to ask that.
>>>
>>> Thus, when you admitted that your input wasn't actually a description
>>> of a program, but just a template, you were admitting that you were
>>> lying about working on the Halting Problem, as your input isn't of
>>> the right type.
>>>
>>> Yes, asking about a template IS an invalid question.
>>>
>>>>  >
>>>>  > (2) The set of questions that are defined to not have any possible
>>>>  > correct answer(s) forms a proper subset of all possible questions.
>>>>  > …
>>>
>>> And, when you are asking the actual Halting Question, about a
>>> specific machine and input, like a SPECIFIC H^, built to foil a
>>> SPECIIFIC H, then that input has a specific and definate behavior and
>>> there is a specific and definate answer (That depends on the H that
>>> you chose to build it on, but not the decider you are asking the
>>> question to).
>>>
>>>>  > CONCLUSION:
>>>>  > Therefore the Halting Problem is an ill-formed question.
>>>>  >
>>>
>>> Nope, as explained above. You are just showing that you never
>>> understood the actual question or what any of the theory actually
>>> means, and have just wasted the last decades of your life on a stupid
>>> misconception of your own.
>>>
>>>> USENET Message-ID:
>>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>>
>>>> *Direct Link to original message*
>>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> That YES and NO are the wrong answer for each implementation of
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves that the
>> questions asked of these machine/inputs pairs are incorrect questions.
>
> An incorrect answer does not mean that the question is incorrect.
>


Click here to read the complete article
H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

<usn67f$3ltl1$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
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
Subject: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when report
s_on_the_actual_behavior_that_it_sees
Date: Mon, 11 Mar 2024 09:58:55 -0500
Organization: A noiseless patient Spider
Lines: 31
Message-ID: <usn67f$3ltl1$1@dont-email.me>
References: <usia2e$2f2pd$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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
<usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org>
<usm3eg$3em6b$1@dont-email.me> <usmnka$3imd4$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 14:58:55 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3864225"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+43zmVQQXoGz7iyf/bZLh6"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:b2fHtrAQpZgezReQDfQT30KFpog=
Content-Language: en-US
In-Reply-To: <usmnka$3imd4$1@dont-email.me>
 by: olcott - Mon, 11 Mar 2024 14:58 UTC

On 3/11/2024 5:49 AM, Mikko wrote:
> On 2024-03-11 05:05:19 +0000, olcott said:
>
>> Does your input halt on its input?
>> is an incorrect question for each Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> It is incorrect in sthe sense that it is not the question
> asked in the halting problem. Otherwise it can be a reasonable
> question.
>

*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) If simulating halt decider H correctly simulates its input D until H
correctly determines that its simulated D would never stop running
unless aborted then
(b) H can abort its simulation of D and correctly report that D
specifies a non-halting sequence of configurations.

When simulating termination analyzer H ⟨Ĥ⟩ ⟨Ĥ⟩ computes
the mapping from its input to its own final state on
the basis of the behavior that it actually sees then
halting is always computable.

Expecting it to compute the mapping from its input on
the basis of behavior that it does not see is incorrect.

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

<usn68f$3lu2i$2@dont-email.me>

  copy mid

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

  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: Mon, 11 Mar 2024 15:59:26 +0100
Organization: A noiseless patient Spider
Lines: 53
Message-ID: <usn68f$3lu2i$2@dont-email.me>
References: <usia2e$2f2pd$1@dont-email.me> <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>
<usljui$385q4$2@dont-email.me> <uslmh7$38jtu$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 14:59:27 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="888d5c2b4a7a39ea1bd55d37c91a1b7c";
logging-data="3864658"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19+E5EmsQ+oRYGvDswFTORU"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:m1HmmLX1BWXruMO2msNEOm0MahU=
In-Reply-To: <uslmh7$38jtu$2@dont-email.me>
Content-Language: en-US
 by: immibis - Mon, 11 Mar 2024 14:59 UTC

On 11/03/24 02:24, olcott wrote:
> On 3/10/2024 7:40 PM, immibis wrote:
>> On 10/03/24 20:16, 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.
>>
>> And now we are back to: Every Turing machine and input pair defines an
>> execution sequence. Every sequence is either finite or infinite.
>> Therefore it is well-defined and there is no paradox.
>>
>> Can you show me a Turing machine that specifies a sequence of
>> configurations that is not finite or infinite?
>
> When we construe every yes/no question that cannot possibly
> have a correct yes/no answer as an incorrect question

Can you show me a Turing machine that specifies a sequence of
configurations that is not finite or infinite?

H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

<usn6fo$3ltl1$2@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
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
Subject: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when report
s_on_the_actual_behavior_that_it_sees
Date: Mon, 11 Mar 2024 10:03:20 -0500
Organization: A noiseless patient Spider
Lines: 540
Message-ID: <usn6fo$3ltl1$2@dont-email.me>
References: <usia2e$2f2pd$1@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> <usl1c7$1enef$9@i2pn2.org>
<usll3l$38f21$1@dont-email.me> <lttHN.366350$q3F7.85039@fx45.iad>
<uslou1$390q2$1@dont-email.me> <uslpbr$1enef$17@i2pn2.org>
<uslu1i$3do6h$1@dont-email.me> <usm07p$1enef$21@i2pn2.org>
<usm1sg$3ebq5$2@dont-email.me> <usm2ps$1enef$22@i2pn2.org>
<usm3eg$3em6b$1@dont-email.me> <usm4id$1enef$24@i2pn2.org>
<usm5np$3f27j$2@dont-email.me> <usmnq5$3io83$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 15:03:20 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3864225"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19OxrkuHdZ7MQbCSTq5R9qA"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:OjZcgntS8UHULL0oqHSN3FOJJL4=
Content-Language: en-US
In-Reply-To: <usmnq5$3io83$1@dont-email.me>
 by: olcott - Mon, 11 Mar 2024 15:03 UTC

On 3/11/2024 5:52 AM, Mikko wrote:
> On 2024-03-11 05:44:25 +0000, olcott said:
>
>> On 3/11/2024 12:24 AM, Richard Damon wrote:
>>> On 3/10/24 10:05 PM, olcott wrote:
>>>> On 3/10/2024 11:54 PM, Richard Damon wrote:
>>>>> On 3/10/24 9:38 PM, olcott wrote:
>>>>>> On 3/10/2024 11:10 PM, Richard Damon wrote:
>>>>>>> On 3/10/24 8:33 PM, olcott wrote:
>>>>>>>> On 3/10/2024 9:13 PM, Richard Damon wrote:
>>>>>>>>> On 3/10/24 7:05 PM, olcott wrote:
>>>>>>>>>> On 3/10/2024 8:52 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/10/24 6:00 PM, olcott wrote:
>>>>>>>>>>>> On 3/10/2024 2:23 PM, Richard Damon wrote:
>>>>>>>>>>>>> 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>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Of course it can abort its simulation.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It just needs some way to get the right answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *I have always been using this long before I read about it*
>>>>>>>>>>>> blind variation and selective retention (BVSR)...
>>>>>>>>>>>> Two common phenomena characterize BVSR thinking: superfluity
>>>>>>>>>>>> and backtracking. Superfluity means that the creator
>>>>>>>>>>>> generates a variety of ideas, one or more of which turn out
>>>>>>>>>>>> to be useless.
>>>>>>>>>>>
>>>>>>>>>>> But if you have mo idea how things actually works, this seems
>>>>>>>>>>> to just generate random noise.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Backtracking signifies that the creator must often return to
>>>>>>>>>>>> an earlier approach after blindly going off in the wrong
>>>>>>>>>>>> direction.
>>>>>>>>>>>> https://www.scientificamerican.com/article/the-science-of-genius/
>>>>>>>>>>>>
>>>>>>>>>>>> *I am aware of no one else that had the idea to apply a
>>>>>>>>>>>> simulating* *termination analyzer to the halting problem
>>>>>>>>>>>> counter-example input*
>>>>>>>>>>>> Professor Hehner had a seed of this idea before I did.
>>>>>>>>>>>
>>>>>>>>>>> Nope, I remember talk of that when I was in college, and they
>>>>>>>>>>> showed why it can't work.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>  From a programmer's point of view, if we apply an
>>>>>>>>>>>> interpreter to a
>>>>>>>>>>>> program text that includes a call to that same interpreter
>>>>>>>>>>>> with that
>>>>>>>>>>>> same text as argument, then we have an infinite loop. A
>>>>>>>>>>>> halting program
>>>>>>>>>>>> has some of the same character as an interpreter: it applies
>>>>>>>>>>>> to texts
>>>>>>>>>>>> through abstract interpretation. Unsurprisingly, if we apply
>>>>>>>>>>>> a halting
>>>>>>>>>>>> program to a program text that includes a call to that same
>>>>>>>>>>>> halting
>>>>>>>>>>>> program with that same text as argument, then we have an
>>>>>>>>>>>> infinite loop. https://www.cs.toronto.edu/~hehner/PHP.pdf
>>>>>>>>>>>
>>>>>>>>>>> You THINK so, but if the interpreter is a CONDITIONAL
>>>>>>>>>>> interpreter, that doesn't hold.
>>>>>>>>>>>
>>>>>>>>>>> You seem to miss that fact.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *Turing Machine and Olcott machine implementations seem to
>>>>>>>>>>>> be dead*
>>>>>>>>>>>> *This the (possibly augmented) RASP machine equivalent of x86*
>>>>>>>>>>>> Every machine must be able to get its own machine address.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And the reason it is a dead end is they make it too hard for
>>>>>>>>>>> you to cheat.
>>>>>>>>>>>
>>>>>>>>>>> You need to hide that your H is trying to get in some extra
>>>>>>>>>>> information to hide that the embedded version of H doesn't
>>>>>>>>>>> give the same answer, which just shows that your H^ is built
>>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>>> My C code proves these two have different behavior:
>>>>>>>>>> (a) H1(D,D) + H1_machine_address
>>>>>>>>>> (b) H(D,D) + H_machine_address
>>>>>>>>>> H1(D,D) does correctly determine the halt status of D(D) because
>>>>>>>>>> H(D,D) does NOT correctly determine the halt status of D(D).
>>>>>>>>>>
>>>>>>>>>> I say:
>>>>>>>>>> H1(D,D) is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>> H(D,D) is isomorphic to Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>>>
>>>>>>>>>> immibis disagrees.
>>>>>>>>>> Correct reasoning will show who is correct.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, and since H1 is a different computation than H, it getting
>>>>>>>>> the right answer doesn't keep H from being broken.
>>>>>>>>>
>>>>>>>>> We can then make a D1 to break H1.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I think that immibis already said that and I did not notice
>>>>>>>> the significance of it at the time.
>>>>>>>>
>>>>>>>
>>>>>>> Of course.
>>>>>>>
>>>>>>>> Then we are back to undecidability being incorrectly construed
>>>>>>>> as an actual limit to computation.
>>>>>>>
>>>>>>> Strange definition of not an actual limit if not being able to do
>>>>>>> something isn't a limit.
>>>>>>>
>>>>>>>>
>>>>>>>> Professor's Hehner and Stoddart have only construed this as
>>>>>>>> applying to the Halting Problem's pathological input.
>>>>>>>>
>>>>>>>> We three perfectly agree on this as it pertains to the
>>>>>>>> Halting Problem.
>>>>>>>>
>>>>>>>> That two full PhD professors of computer science and I all
>>>>>>>> agree on this shows that I am not a crackpot/crank on this.
>>>>>>>> I think that all of the other options may now be exhausted.
>>>>>>>>
>>>>>>>> I am very happy that I quit tolerating the [change the subject]
>>>>>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>>>>>>
>>>>>>>> *The focus now must be on finding the best words that prove*
>>>>>>>> *this original position of mine (thus the concurring positions*
>>>>>>>> *of professors Hehner and Stoddart) is correct*
>>>>>>>
>>>>>>> Go knock yourself out on that.
>>>>>>>
>>>>>>>>
>>>>>>>> Alan Turing's Halting Problem is incorrectly formed (PART-TWO)
>>>>>>>> sci.logic
>>>>>>>> On 6/20/2004 11:31 AM, Peter Olcott wrote:
>>>>>>>>  > PREMISES:
>>>>>>>>  > (1) The Halting Problem was specified in such a way that a
>>>>>>>> solution
>>>>>>>>  > was defined to be impossible.
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> The PROBLEM is the question if a machine can compute the Halting
>>>>>>> Function.
>>>>>>>
>>>>>>> The answer to that, has turned out to be NO.
>>>>>>>
>>>>>>> When the problem was first being posed, it was hoped the answer
>>>>>>> woudl be yes, so it couldn't have bee made specifically to make
>>>>>>> it impossible.
>>>>>>>
>>>>>>>
>>>>>>> The Halting QUESTION, has an answer for every input that it the
>>>>>>> description of an actual algorithm applied to an actual data input.
>>>>>>>
>>>>>>> Note, Not a "Template" that gets appled to the decider, that IS
>>>>>>> an invalid question, and impossible to build a description of a
>>>>>>> Turing Machine to ask that.
>>>>>>>
>>>>>>> Thus, when you admitted that your input wasn't actually a
>>>>>>> description of a program, but just a template, you were admitting
>>>>>>> that you were lying about working on the Halting Problem, as your
>>>>>>> input isn't of the right type.
>>>>>>>
>>>>>>> Yes, asking about a template IS an invalid question.
>>>>>>>
>>>>>>>>  >
>>>>>>>>  > (2) The set of questions that are defined to not have any
>>>>>>>> possible
>>>>>>>>  > correct answer(s) forms a proper subset of all possible
>>>>>>>> questions.
>>>>>>>>  > …
>>>>>>>
>>>>>>> And, when you are asking the actual Halting Question, about a
>>>>>>> specific machine and input, like a SPECIFIC H^, built to foil a
>>>>>>> SPECIIFIC H, then that input has a specific and definate behavior
>>>>>>> and there is a specific and definate answer (That depends on the
>>>>>>> H that you chose to build it on, but not the decider you are
>>>>>>> asking the question to).
>>>>>>>
>>>>>>>>  > CONCLUSION:
>>>>>>>>  > Therefore the Halting Problem is an ill-formed question.
>>>>>>>>  >
>>>>>>>
>>>>>>> Nope, as explained above. You are just showing that you never
>>>>>>> understood the actual question or what any of the theory actually
>>>>>>> means, and have just wasted the last decades of your life on a
>>>>>>> stupid misconception of your own.
>>>>>>>
>>>>>>>> USENET Message-ID:
>>>>>>>> <kZiBc.103407$Gx4.18142@bgtnsc04-news.ops.worldnet.att.net>
>>>>>>>>
>>>>>>>> *Direct Link to original message*
>>>>>>>> http://al.howardknight.net/?STYPE=msgid&MSGI=%3CkZiBc.103407%24Gx4.18142%40bgtnsc04-news.ops.worldnet.att.net%3E+
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> That YES and NO are the wrong answer for each implementation of
>>>>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ specified by the second ⊢* state transition proves
>>>>>> that the
>>>>>> questions asked of these machine/inputs pairs are incorrect
>>>>>> questions.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> Justs shows how must of a stupid idiot you are, because you just
>>>>> ignored the explaination.
>>>>>
>>>>
>>>> You don't seem to understand that every element of a set that shares
>>>> common properties all have these same properties in common.
>>>
>>> But not if they have different properties.
>>>
>>> You don't seem to understand that.
>>>
>>>>
>>>> Does your input halt on its input?
>>>> is an incorrect question for each Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>>
>>> WHY?
>>>
>>> EACH INDIVIDUAL INPUT HAS A CORRECT ANSWER
>>>
>>>>
>>>> All of the Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that transition to Ĥ.Hqy answer incorrectly.
>>>
>>> But there IS a correct answer, non-halting
>>>
>>>> All of the Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that transition to Ĥ.Hqn answer incorrectly.
>>>
>>> But there IS a correct answer, Halting,
>>>
>>> If H (H^) (H^) goes to qy, it can NEVER go to qn for that input and
>>> be the same machine, so the question about what should we change H to
>>> do, is just improper.
>>>
>>>>
>>>> Now we run ran out of all of the elements of the infinite set
>>>> of each possible implementation of Ĥ.H. They all get the wrong
>>>> answer to this question: Does your input halt on its input?
>>>
>>> Right, that makes the question UNCOMPUTABLE, not invalid.
>>>
>>> EVERY QUESTION had a right answer (we aren't asking what H should
>>> return to be right, but what is the right answer, and IS H right)
>>>
>>> You are just proving you don't understand the question.
>>>
>>> And the problem seems so deep, it is clear you have brainwashed
>>> yourself so you can't believe (or are just that good of a
>>> pathological liar)
>>>
>>> This is self-inflicted, as you CHOSE to not learn the terms of the
>>> field, afraid they would brainwash you into false thought. Instead
>>> you chose the "supperior" path of going out intentionally ignorant of
>>> the system and just make mistakes at every turn.
>>>
>>
>> *Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
>
> For each H there is only one Ĥ as defined by Linz.
>


Click here to read the complete article
H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when reports on the actual behavior that it sees

<usn6l2$3ltl1$3@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory
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
Subject: H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when report
s_on_the_actual_behavior_that_it_sees
Date: Mon, 11 Mar 2024 10:06:10 -0500
Organization: A noiseless patient Spider
Lines: 66
Message-ID: <usn6l2$3ltl1$3@dont-email.me>
References: <usia2e$2f2pd$1@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> <usljui$385q4$2@dont-email.me>
<uslmh7$38jtu$2@dont-email.me> <usmo12$3io83$2@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 11 Mar 2024 15:06:10 -0000 (UTC)
Injection-Info: dont-email.me; posting-host="1568d5e95fd7d0d459fb89959682569c";
logging-data="3864225"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+R6FAnyq8xCUgxQPO0pXnw"
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:IGSf3qcPLrzw0iij5wxx8Wjf4Ic=
Content-Language: en-US
In-Reply-To: <usmo12$3io83$2@dont-email.me>
 by: olcott - Mon, 11 Mar 2024 15:06 UTC

On 3/11/2024 5:56 AM, Mikko wrote:
> On 2024-03-11 01:24:55 +0000, olcott said:
>
>> On 3/10/2024 7:40 PM, immibis wrote:
>>> On 10/03/24 20:16, 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.
>>>
>>> And now we are back to: Every Turing machine and input pair defines
>>> an execution sequence. Every sequence is either finite or infinite.
>>> Therefore it is well-defined and there is no paradox.
>>>
>>> Can you show me a Turing machine that specifies a sequence of
>>> configurations that is not finite or infinite?
>>
>> When we construe every yes/no question that cannot possibly
>> have a correct yes/no answer as an incorrect question
>>
>> then we must correspondingly construe every decider/input
>> pair that has no correct yes/no answer as invalid input.
>
> Apparently the answer is "no" as no such Turing machine is shown
> or mentioned above.
>

*Every implementation of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer*
This proves that there is something wrong with the question.

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

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

Pages:12345678910111213
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor