Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

What is mind? No matter. What is matter? Never mind. -- Thomas Hewitt Key, 1799-1875


computers / comp.ai.philosophy / Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

SubjectAuthor
* H(P,P)==0 is correct for every simulating halt decider H --- V2olcott
+- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2olcott
+* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2olcott
|`* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2olcott
| `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2olcott
|  +* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition olcott
|  |+* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition olcott
|  ||`* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [André G. Isaak
|  || `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  ||  `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  ||   `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossiblyolcott
|  ||    `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  ||     `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  ||      +- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  ||      `- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  |`* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  | +* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  | |+- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  | |`* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  | | `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  | |  `- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  | `- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|  `* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
|   `- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [olcott
`- Re: H(P,P)==0 is correct for every simulating halt decider H --- V2olcott

1
H(P,P)==0 is correct for every simulating halt decider H --- V2

<ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7521&group=comp.ai.philosophy#7521

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 31 Oct 2021 22:45:41 -0500
Date: Sun, 31 Oct 2021 22:45:40 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: H(P,P)==0 is correct for every simulating halt decider H --- V2
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
Lines: 36
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-IEDkw6fST3WpZUxqlM5/02rLrZcgrgWZTL59PNXrPsz6xH3rQWi91hzJ125syt1E8NoTU4KyfjCAtaL!Ix4v1ZN1tag0KJ4KMnUyPtW+Fp8BvkN16vBqcC3p/cptdLiYuQ2UgAecuNUb3Mw12JLAYvAQP/ZE!xw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2316
 by: olcott - Mon, 1 Nov 2021 03:45 UTC

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

We can analyze H(P,P) at the very high level of abstraction of its two
possible behaviors relative to its input allows us to concisely prove
that not halting <is> the correct decision for this input. No matter how
H works internally the only thing that counts is the behavior of its
input for the two possible behaviors that H can have.

Since the input to H(P,P) never reaches its final state for the two
possible behaviors that every H can possibly have (abort the input or do
not abort the input) then we can conclude that not halting is the
correct decision for every possible simulating halt decider H.

Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2

<cfCdnZHrKNe5Y-L8nZ2dnUU7-cWdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7522&group=comp.ai.philosophy#7522

 copy link   Newsgroups: comp.theory sci.logic sci.math comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 01 Nov 2021 09:48:04 -0500
Date: Mon, 1 Nov 2021 09:48:03 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,sci.math,comp.ai.philosophy
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<2b57e1b4-b926-41fd-bbd5-1dae8ed6dbe2n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <2b57e1b4-b926-41fd-bbd5-1dae8ed6dbe2n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <cfCdnZHrKNe5Y-L8nZ2dnUU7-cWdnZ2d@giganews.com>
Lines: 150
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ikdVgEgxIhtKxQ7GBm1Wcq6K7K3T0MJ9+3iwCIw6TvRbXcbn5a8L7SSbDfDvKRUIc6lMlThE43DQH7V!nd3uXQakeMqU8LFEvaLG6fN9fi+qNigeAJVBC4G+xVH3KnRxdeoHX12otCP3z7KM0cRpGPXtajrK!dQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 7204
 by: olcott - Mon, 1 Nov 2021 14:48 UTC

On 11/1/2021 7:46 AM, Malcolm McLean wrote:
> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>> // Simplified Linz Ĥ (Linz:1990:319)
>> // Strachey(1965) CPL translated to C
>> void P(u32 x)
>> {
>> if (H(x, x))
>> HERE: goto HERE;
>> }
>>
>> int main()
>> {
>> Output("Input_Halts = ", H((u32)P, (u32)P));
>> }
>>
>> We can analyze H(P,P) at the very high level of abstraction of its two
>> possible behaviors relative to its input allows us to concisely prove
>> that not halting <is> the correct decision for this input. No matter how
>> H works internally the only thing that counts is the behavior of its
>> input for the two possible behaviors that H can have.
>>
>> Since the input to H(P,P) never reaches its final state for the two
>> possible behaviors that every H can possibly have (abort the input or do
>> not abort the input) then we can conclude that not halting is the
>> correct decision for every possible simulating halt decider H.
>>
> I can see where the confusion lies. If H never aborts, it simulates P forever.
> If it aborts, then it aborts because it has detected that otherwise P would
> simulate forever.
>
> What you are forgetting is that P depends on H. If H aborts, the P would also
> abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
> that if it didn't abort, P would run forever.
> That seems like a contradiction, but it isn't really, because we are talking
> about two Ps, one with an H which never aborts, one with an H that aborts.
>

void Infinite_Loop()
{ HERE: goto HERE;
}

_Infinite_Loop()
[00000ab0](01) 55 push ebp
[00000ab1](02) 8bec mov ebp,esp
[00000ab3](02) ebfe jmp 00000ab3
[00000ab5](01) 5d pop ebp
[00000ab6](01) c3 ret
Size in bytes:(0007) [00000ab6]

If H allows Infinite_Loop() to continue then Infinite_Loop() never
reaches its final state of 0xab6. If H aborts its simulation of
Infinite_Loop() then it stops at 0xab3 and never reaches its final state
of 0xab6. H(P,P) is the same situation:

We are talking about this case shown below which conclusively proves
that every simulating halt decider H must abort its simulation its input
otherwise (just like the infinite loop shown above) its input never halts.

Aborting the input does not count as halting because the input never
reaches its final state no matter what H does. Any input that never
reaches its final state NO MATTER WHAT is an input that never halts.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

_main()
[00000c56](01) 55 push ebp
[00000c57](02) 8bec mov ebp,esp
[00000c59](05) 68360c0000 push 00000c36 // push P
[00000c5e](05) 68360c0000 push 00000c36 // push P
[00000c63](05) e8fefcffff call 00000966 // call H(P,P)
[00000c68](03) 83c408 add esp,+08
[00000c6b](01) 50 push eax
[00000c6c](05) 6857030000 push 00000357
[00000c71](05) e810f7ffff call 00000386
[00000c76](03) 83c408 add esp,+08
[00000c79](02) 33c0 xor eax,eax
[00000c7b](01) 5d pop ebp
[00000c7c](01) c3 ret
Size in bytes:(0039) [00000c7c]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c56][0010172a][00000000] 55 push ebp
[00000c57][0010172a][00000000] 8bec mov ebp,esp
[00000c59][00101726][00000c36] 68360c0000 push 00000c36 // push P
[00000c5e][00101722][00000c36] 68360c0000 push 00000c36 // push P
[00000c63][0010171e][00000c68] e8fefcffff call 00000966 // call H(P,P)

Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

[00000c36][0025c1f2][0025c1f6] 55 push ebp
[00000c37][0025c1f2][0025c1f6] 8bec mov ebp,esp
[00000c39][0025c1f2][0025c1f6] 8b4508 mov eax,[ebp+08]
[00000c3c][0025c1ee][00000c36] 50 push eax // push P
[00000c3d][0025c1ee][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][0025c1ea][00000c36] 51 push ecx // push P
[00000c41][0025c1e6][00000c46] e820fdffff call 00000966 // call H(P,P)
Local Halt Decider: Infinite Recursion Detected Simulation Stopped

The above if from pages 4 and 5
Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2

<mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7523&group=comp.ai.philosophy#7523

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 01 Nov 2021 09:54:22 -0500
Date: Mon, 1 Nov 2021 09:54:20 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <874k8wrvxv.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
Lines: 36
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-gNbXkGBFil7Z2EyLkawyqdwve1r7ehyQne55L+yPrk5QsTqdVchLJWSp7glB+GSMqmoF58wXf7p1OUo!OTEQVJW5yM8HwUomL9M4denCXjjRJnOKKWomMa7VxcCWbaLcINWh3AkS5QU8P609aPDClzZTN6M2!6Q==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2364
 by: olcott - Mon, 1 Nov 2021 14:54 UTC

On 11/1/2021 5:50 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
> Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
>
> No. H(P,P) == 0 is correct if, and only if, P(P) does not halt. But
> (according to you -- we are not allowed to see the full code) P(P)
> halts:
>

No matter what the code is for H every possible H must abort its
simulation of (P,P) otherwise this input never halts.

> || Here's the key question: do you still assert that H(P,P) == false is
> || the "correct" answer even though P(P) halts?
>

H(P,P) reports that its input never halts.
It is indeed a verified fact that its input never halts.
When you argue with verified facts you diverge from rationality.

H1(P,P) reports that P(P) halts.

Both are correct.

> | Yes that is the correct answer even though P(P) halts.
>
> No waffle can alter the fact that false (or 0 etc.) is the wrong return.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2

<RNidnf2ewJAsmR38nZ2dnUU7-c3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7524&group=comp.ai.philosophy#7524

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 01 Nov 2021 10:16:01 -0500
Date: Mon, 1 Nov 2021 10:15:59 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<2b57e1b4-b926-41fd-bbd5-1dae8ed6dbe2n@googlegroups.com>
<87v91cq7af.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87v91cq7af.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <RNidnf2ewJAsmR38nZ2dnUU7-c3NnZ2d@giganews.com>
Lines: 87
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-PqRAjaUDB3BGBeS0v2v6fOSvh+SrJBAC3IlvOtaIss1t6cSarYcQvSeY24oL3LXQXX5ZK6iDFETvMFD!amwvzToIxI33dGND4xciabyraYleN2lM9ITCrWW4k4rOMV0a96bBKEm3ytRQQeBjITnyHmJXquvz!Eg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4903
 by: olcott - Mon, 1 Nov 2021 15:15 UTC

On 11/1/2021 9:28 AM, Ben Bacarisse wrote:
> Malcolm McLean <malcolm.arthur.mclean@gmail.com> writes:
>
>> On Monday, 1 November 2021 at 03:45:47 UTC, olcott wrote:
>>> // Simplified Linz Ĥ (Linz:1990:319)
>>> // Strachey(1965) CPL translated to C
>>> void P(u32 x)
>>> {
>>> if (H(x, x))
>>> HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)P, (u32)P));
>>> }
>>>
>>> We can analyze H(P,P) at the very high level of abstraction of its two
>>> possible behaviors relative to its input allows us to concisely prove
>>> that not halting <is> the correct decision for this input. No matter how
>>> H works internally the only thing that counts is the behavior of its
>>> input for the two possible behaviors that H can have.
>>>
>>> Since the input to H(P,P) never reaches its final state for the two
>>> possible behaviors that every H can possibly have (abort the input or do
>>> not abort the input) then we can conclude that not halting is the
>>> correct decision for every possible simulating halt decider H.
>>>
>> I can see where the confusion lies. If H never aborts, it simulates P forever.
>> If it aborts, then it aborts because it has detected that otherwise P would
>> simulate forever.
>>
>> What you are forgetting is that P depends on H.
>
> What makes you think he's forgetting that? Having (at least) two
> different Hs without changing H^ (now called P) has been the ruse for
> months and months.
>
> His Halts function was declared correct because of what would happen if
> line 15 were commented out. It has always been some variation of the
> theme of "the wrong answer is right because of what would happen if H
> (but not H^) were not the function it really is".
>

No matter what the code is for H every possible H must abort its
simulation of (P,P) otherwise this input never halts.

Whether or not H(P,P) aborts its simulation of its input this input
reaches its final state, thus in all cases the input to H(P,P) never
reaches its final state thus in all cases the input to H(P,P) matches
the definition of not halting.

Now that I have generalized my proof such that this proof can be
directly applied to the Linz it is in a form that is in the ballpark of
what academic journals would accept.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ reaches Ĥ.qy

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
If the pure simulation of the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach
Ĥ.qy or Ĥ.qn

Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

>> If H aborts, the P would also
>> abort i.e. terminate. So if H aborts P, it aborts incorrectly, despite the fact
>> that if it didn't abort, P would run forever.
>> That seems like a contradiction, but it isn't really, because we are talking
>> about two Ps, one with an H which never aborts, one with an H that
>> aborts.
>
> Do you think the change of name from a dependent one (H^) to one that
> hides the dependence (P) is an accident? Might is not be part of the
> scheme to find words that make the wrong answer, H(P,P) == false, seem
> less wrong despite the fact that P(P) halts?
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2

<heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7525&group=comp.ai.philosophy#7525

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 01 Nov 2021 19:11:37 -0500
Date: Mon, 1 Nov 2021 19:11:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87ee7zqz75.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
Lines: 26
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kxOB5XCJhBhZnXQjJO5yb9dLvl5GYNFqD4xmkVotYHbq4DtwAdp37DgUDd4ntM3Nn6FHUoVAArRirZV!UwmWfiq+gJh9mwSe8nKzQe8SIJEafGN3zG482Via7LzB1SDZ3zmSQb8XSP7yjJRR9KJds0ZxOFzQ!yQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 2133
 by: olcott - Tue, 2 Nov 2021 00:11 UTC

On 11/1/2021 5:38 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>>> || Here's the key question: do you still assert that H(P,P) == false is
>>> || the "correct" answer even though P(P) halts?
>
> To which you replied (but have for some reason cut from this post)
>
>>> | Yes that is the correct answer even though P(P) halts.
>
>> H(P,P) reports that its input never halts.
>
> H(P,P) should report on whether P(P) halts. Stating that the wrong
> answer is the right one is not how mathematics is done.
>

H1(P,P) is computationally equivalent to P(P).
H(P,P) is not computationally equivalent to P(P).

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2

<xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7526&group=comp.ai.philosophy#7526

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder5.feed.usenet.farm!feeder1.feed.usenet.farm!feed.usenet.farm!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 09:20:47 -0500
Date: Tue, 2 Nov 2021 09:20:45 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com> <874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com> <87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com> <87lf26pueb.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87lf26pueb.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5xMJ85Cu40C6RaA1GEF0iXHdtiimrfWWoerEaLrKwyw+fQj+9xO/ty1j734N+3HbEzPQKfeQ3RlyhtV!v/1el8AcjV1BSp4p1FDpUd6bkyta96bd3waotchqXff5WETDPqmcQrMrPQffy73PxtuFqeS0BwNg!Zw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3806
 by: olcott - Tue, 2 Nov 2021 14:20 UTC

On 11/2/2021 8:19 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/1/2021 5:38 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>> || Here's the key question: do you still assert that H(P,P) == false is
>>>>> || the "correct" answer even though P(P) halts?
>>> To which you replied (but have for some reason cut from this post)
>>>
>>>>> | Yes that is the correct answer even though P(P) halts.
>>>
>>>> H(P,P) reports that its input never halts.
>>> H(P,P) should report on whether P(P) halts. Stating that the wrong
>>> answer is the right one is not how mathematics is done.
>>
>> H1(P,P) is computationally equivalent to P(P).
>> H(P,P) is not computationally equivalent to P(P).
>
> H(P,P) == false is wrong if P(P) halts.

The input to H(P,P) really does never halt this has been conclusively
proven. That you keep ignoring the verified fact that the input to
H(P,P) has been totally proven to never reaches its final state sure
seems to be an irrational break from reality to me.

It really seems that P(P) should have behavior consistent with H(P,P).
Intuitively they seem to be the same computation. When they don't have
behavior that is consistent with each other this merely proves that
intuition was wrong. Intuition is not infallible. Running the actual
code does infallibly show what the code actually does.

Since a halt decider is supposed to report what its input actually does
we still have H1(P,P) that does just that.

The whole issue with the halting problem proofs is that an input was
intentionally designed to thwart the halt decider. This has always been
understood to be an input that does the opposite of whatever the halt
decider decides.

One of the two halt deciders does get an answer that is consistent with
the behavior of its input.

> This comes from the definition
> of the problem you have been studying for more than 14 years. I think
> it's time you did something else. It seems such a waste...
>

H1(P,P) is computationally equivalent to P(P) and and reports that P(P)
halts. This is the same as applying H to ⟨Ĥ⟩ ⟨Ĥ⟩ which was something
that Linz "proved" was impossible.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7527&group=comp.ai.philosophy#7527

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 10:57:09 -0500
Date: Tue, 2 Nov 2021 10:57:06 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com> <874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com> <87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com> <87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com> <874k8upp9k.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <874k8upp9k.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
Lines: 116
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sw6bGTUjgGUe4cBGLRAI9OHWE6CeOiSUPpssqOb/U7INsopkRytoTnTO3enwVE2aRMZi5gSp5AOYkED!dUlepFFGkAMcClX4ifZI2cGzUI9L+HwfuxIP6R3eCFbiFX57R1L5yCSLZxZhGrgMUXhH6cFEAk15!/A==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6139
 by: olcott - Tue, 2 Nov 2021 15:57 UTC

On 11/2/2021 10:10 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/2/2021 8:19 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/1/2021 5:38 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>> || Here's the key question: do you still assert that H(P,P) == false is
>>>>>>> || the "correct" answer even though P(P) halts?
>>>>> To which you replied (but have for some reason cut from this post)
>>>>>
>>>>>>> | Yes that is the correct answer even though P(P) halts.
>>>>>
>>>>>> H(P,P) reports that its input never halts.
>>>>> H(P,P) should report on whether P(P) halts. Stating that the wrong
>>>>> answer is the right one is not how mathematics is done.
>>>>
>>>> H1(P,P) is computationally equivalent to P(P).
>>>> H(P,P) is not computationally equivalent to P(P).
>>> H(P,P) == false is wrong if P(P) halts.
>>
>> The input to H(P,P) really does never halt this has been conclusively
>> proven.
>
> P(P) halts. H(P,P) == false is the wrong answer if P(P) halts.
>
>> That you keep ignoring the verified fact that the input to H(P,P) has
>> been totally proven to never reaches its final state sure seems to be
>> an irrational break from reality to me.
>
> You want me to get sucked into discussing your other errors, but really
> only one counts: H(P,P) == false is the wrong answer if P(P) halts.
>

As long as H(P,P)==0 is correct none of my other "errors" are of any
consequence what-so-ever. I have conclusively proved that the input to
H(P,P) cannot possibly ever reach its final state for every possible
encoding of simulating halt decider H.

// Simplified Linz Ĥ (Linz:1990:319)
// Strachey(1965) CPL translated to C
void P(u32 x)
{ if (H(x, x))
HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H((u32)P, (u32)P));
}

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
Begin Local Halt Decider Simulation at Machine Address:c36
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

There are only two possible behaviors for every possible encoding of
simulating halt decider H and only one of these behaviors is correct:

(1) Continue to act as a pure simulator that never aborts the simulation
of its input. This causes the first seven instructions of P to
infinitely repeat. (You might not know the x86 language well enough to
see this).

(2) Abort the simulation of P at one of the machine addresses of P
between 0xc36 to 0xc41 at some point in the simulation of P.

Those are the only two possibilities for every possible encoding of
simulating halt decider H.

Because we applied categorically exhaustive reasoning to H(P,P) we know
that there are no gaps in this reasoning. Every possible encoding of
simulating halt decider H either aborts its simulation of its input or
fails to abort the simulation of its input. There is no third option.

Since for every possible encoding of simulating halt decider H for every
possible abort versus not abort behavior of H(P,P) the input never
reaches its final state we know know with logically justified complete
certainty that the input to H(P,P) never halts thus H(P,P)==0 is correct.

The fact that correct logic contradicts your intuition merely proves
that your intuition is incorrect.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7528&group=comp.ai.philosophy#7528

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 15:24:19 -0500
Date: Tue, 2 Nov 2021 15:24:17 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com> <874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com> <87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com> <87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com> <874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com> <87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com> <87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me> <sls5k8$reo$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sls5k8$reo$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
Lines: 103
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oPwmckRandJ5k2xGrY6jVOa4406WFFWW7JC/k2Lgy9vpyhtAa13OvhqqCfqw0CkQKrY3Nr/auRS58yQ!6ywy3qwjihmWqp+dzjsrU5BOBvbmjNlzJI32vHnAsOaEEBLA+9cDVnEar8ssr3jdFp1AgKWlDJ+K!+A==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6238
 by: olcott - Tue, 2 Nov 2021 20:24 UTC

On 11/2/2021 3:04 PM, André G. Isaak wrote:
> On 2021-11-02 11:32, olcott wrote:
>> On 11/2/2021 12:25 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/2/2021 11:15 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>> As long as H(P,P)==0 is correct none of my other "errors" are of any
>>>>>> consequence what-so-ever.
>>>>>
>>>>> That's why I said one error really count: H(P,P)==0 is not correct
>>>>> because P(P) halts.  How is it that you can keep ignoring this?
>>>>
>>>> It is a verified fact that for every possible (abort / do not abort)
>>>> behavior of every possible encoding of simulating halt decider H that
>>>> the input to H(P,P) never reaches its final state.
>>>
>>> H(P,P)==0 is wrong because P(P) halts.  You keep trying to explain some
>>> other decision problem that you think H is getting right.  For the
>>> halting problem -- the one you've been "studying" for more than 14 years
>>> -- H(P,P)==0 is only correct if P(P) does not halt and you've told us
>>> that is does.
>>>
>>>> It is like I am telling there are no integers between 1 and 2 and you
>>>> just don't believe it.
>>>
>>> No, its like you are tell me that H(P,P)==false is the right answer from
>>> a halt decider when P(P) is a halting computation.  In fact it's very
>>> much like that.  Almost exactly like that in fact.
>>>
>>>> It seems to be intuitively true that H(P,P) should report that its
>>>> input halts because P(P) halts.
>>>
>>> No.  I have no intuition about what you even mean because inputs don't
>>> do anything.  What is true by definition (no intuition required) is that
>>> H(P,P) should be false only if P(P) does not halt.
>>>
>>>> This intuition
>>>
>>> I don't have that intuition.  What "the input" does is meaningless.
>>
>> Every halt decider is ONLY tasked with determining the behavior of its
>> input. That you say otherwise is very stupid.
>
> Why don't you go back and reread definition of Halt Decider given in
> 12.1 in Linz.
>
> Let w_M be a string that describes a Turing machine M, and let w be a
> string in M’s alphabet. A solution of the halting problem is a Turing
> machine H, which for any w_M and w performs the computation:
>
> q_0 w_M w ⊢* x_1 q_y x_2 if M applied to w halts, and
> q_0 w_M w ⊢* x_1 q_n x_2 if M applied to w does not halt
>
> The input to this machine is w_M plus the input string w. The conditions
> specified to the two final states make no mention whatsoever of w_M.
> They talk about *M* applied to w.
>

By saying it that way people can be confused (the same way that Linz
himself was confused) into believing that the question is about whether
or not the halt decider itself at Ĥ.qx halts.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

The behavior of the input to the halt decider after Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩
has nothing to do with whether or not the halt decider itself halts.

The fact that the input to H(P,P) never reaches its final state under
both aborting and not aborting behaviors for every possible encoding of
simulating halt decider H conclusively proves that the input to H(P,P)
never halts and H(P,P)==0 is correct.

Shown on pages 4 and 5 of this paper:
Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

The key part to pay attention to it the execution trace of the first
seven lines of the x86 code for P:

Begin Local Halt Decider Simulation at Machine Address:c36
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<sls7ku$aom$1@dont-email.me>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7529&group=comp.ai.philosophy#7529

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
intuition versus logic ]
Date: Tue, 2 Nov 2021 14:38:52 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 98
Message-ID: <sls7ku$aom$1@dont-email.me>
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 2 Nov 2021 20:38:54 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="a74483c0eb2d4725359853d3027f2b83";
logging-data="11030"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/JTJ04mgFrqgVEonUxZqy7"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:78.0)
Gecko/20100101 Thunderbird/78.14.0
Cancel-Lock: sha1:L49fmyUvQVU3VsyMn6RyVUM7fNc=
In-Reply-To: <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 2 Nov 2021 20:38 UTC

On 2021-11-02 14:24, olcott wrote:
> On 11/2/2021 3:04 PM, André G. Isaak wrote:
>> On 2021-11-02 11:32, olcott wrote:
>>> On 11/2/2021 12:25 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 11/2/2021 11:15 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> As long as H(P,P)==0 is correct none of my other "errors" are of any
>>>>>>> consequence what-so-ever.
>>>>>>
>>>>>> That's why I said one error really count: H(P,P)==0 is not correct
>>>>>> because P(P) halts.  How is it that you can keep ignoring this?
>>>>>
>>>>> It is a verified fact that for every possible (abort / do not abort)
>>>>> behavior of every possible encoding of simulating halt decider H that
>>>>> the input to H(P,P) never reaches its final state.
>>>>
>>>> H(P,P)==0 is wrong because P(P) halts.  You keep trying to explain some
>>>> other decision problem that you think H is getting right.  For the
>>>> halting problem -- the one you've been "studying" for more than 14
>>>> years
>>>> -- H(P,P)==0 is only correct if P(P) does not halt and you've told us
>>>> that is does.
>>>>
>>>>> It is like I am telling there are no integers between 1 and 2 and you
>>>>> just don't believe it.
>>>>
>>>> No, its like you are tell me that H(P,P)==false is the right answer
>>>> from
>>>> a halt decider when P(P) is a halting computation.  In fact it's very
>>>> much like that.  Almost exactly like that in fact.
>>>>
>>>>> It seems to be intuitively true that H(P,P) should report that its
>>>>> input halts because P(P) halts.
>>>>
>>>> No.  I have no intuition about what you even mean because inputs don't
>>>> do anything.  What is true by definition (no intuition required) is
>>>> that
>>>> H(P,P) should be false only if P(P) does not halt.
>>>>
>>>>> This intuition
>>>>
>>>> I don't have that intuition.  What "the input" does is meaningless.
>>>
>>> Every halt decider is ONLY tasked with determining the behavior of
>>> its input. That you say otherwise is very stupid.
>>
>> Why don't you go back and reread definition of Halt Decider given in
>> 12.1 in Linz.
>>
>> Let w_M be a string that describes a Turing machine M, and let w be a
>> string in M’s alphabet. A solution of the halting problem is a Turing
>> machine H, which for any w_M and w performs the computation:
>>
>> q_0 w_M w ⊢* x_1 q_y x_2 if M applied to w halts, and
>> q_0 w_M w ⊢* x_1 q_n x_2 if M applied to w does not halt
>>
>> The input to this machine is w_M plus the input string w. The
>> conditions specified to the two final states make no mention
>> whatsoever of w_M. They talk about *M* applied to w.
>>
>
> By saying it that way people can be confused (the same way that Linz

Saying it that way is how halt decider is *defined*. Not just by Linz,
but by *everyone* who has ever discussed this problem.

If you want to discuss the halting problem, this is the definition you
must use.

> himself was confused) into believing that the question is about whether
> or not the halt decider itself at Ĥ.qx halts.

(A) There is no halt decider at Ĥ.qx
(B) There is nothing to get confused about. The input to the submachine
at Ĥ.qx is the string ⟨Ĥ⟩ ⟨Ĥ⟩. Any decision made by Ĥ.qx (which is not a
halting decision) makes a decision about Ĥ applied to ⟨Ĥ⟩.

Ĥ, Ĥ.qx, and w_Ĥ (or ⟨Ĥ⟩ to use your notion) are three different things.
Why would anyone confuse w_Ĥ with Ĥ.qx?

> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The behavior of the input to the halt decider after Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩
> has nothing to do with whether or not the halt decider itself halts.

Nor does the definition given above claim that it does. Any comfusion
here is purely confusion on your part.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7530&group=comp.ai.philosophy#7530

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 15:43:42 -0500
Date: Tue, 2 Nov 2021 15:43:40 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
intuition versus logic ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
<sls7ku$aom$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sls7ku$aom$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>
Lines: 87
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-k6TU9/9+s6drs/Xj3U1X0lqsalqJRpv88Q5MX2osJmhJOYPI8cub9ec0pMdmEpvU1/QkoW0qFTvAub6!qyMST64QEamO41jpLWF+yaDB8uMBJ3sCfnwyS4Mv9WyK2J7enceTuxbrWlFp7VcnQGWBVyfnJsv4!1w==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5300
 by: olcott - Tue, 2 Nov 2021 20:43 UTC

On 11/2/2021 3:38 PM, André G. Isaak wrote:
> On 2021-11-02 14:24, olcott wrote:
>> On 11/2/2021 3:04 PM, André G. Isaak wrote:
>>> On 2021-11-02 11:32, olcott wrote:
>>>> On 11/2/2021 12:25 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 11/2/2021 11:15 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>>> As long as H(P,P)==0 is correct none of my other "errors" are of
>>>>>>>> any
>>>>>>>> consequence what-so-ever.
>>>>>>>
>>>>>>> That's why I said one error really count: H(P,P)==0 is not correct
>>>>>>> because P(P) halts.  How is it that you can keep ignoring this?
>>>>>>
>>>>>> It is a verified fact that for every possible (abort / do not abort)
>>>>>> behavior of every possible encoding of simulating halt decider H that
>>>>>> the input to H(P,P) never reaches its final state.
>>>>>
>>>>> H(P,P)==0 is wrong because P(P) halts.  You keep trying to explain
>>>>> some
>>>>> other decision problem that you think H is getting right.  For the
>>>>> halting problem -- the one you've been "studying" for more than 14
>>>>> years
>>>>> -- H(P,P)==0 is only correct if P(P) does not halt and you've told us
>>>>> that is does.
>>>>>
>>>>>> It is like I am telling there are no integers between 1 and 2 and you
>>>>>> just don't believe it.
>>>>>
>>>>> No, its like you are tell me that H(P,P)==false is the right answer
>>>>> from
>>>>> a halt decider when P(P) is a halting computation.  In fact it's very
>>>>> much like that.  Almost exactly like that in fact.
>>>>>
>>>>>> It seems to be intuitively true that H(P,P) should report that its
>>>>>> input halts because P(P) halts.
>>>>>
>>>>> No.  I have no intuition about what you even mean because inputs don't
>>>>> do anything.  What is true by definition (no intuition required) is
>>>>> that
>>>>> H(P,P) should be false only if P(P) does not halt.
>>>>>
>>>>>> This intuition
>>>>>
>>>>> I don't have that intuition.  What "the input" does is meaningless.
>>>>
>>>> Every halt decider is ONLY tasked with determining the behavior of
>>>> its input. That you say otherwise is very stupid.
>>>
>>> Why don't you go back and reread definition of Halt Decider given in
>>> 12.1 in Linz.
>>>
>>> Let w_M be a string that describes a Turing machine M, and let w be a
>>> string in M’s alphabet. A solution of the halting problem is a Turing
>>> machine H, which for any w_M and w performs the computation:
>>>
>>> q_0 w_M w ⊢* x_1 q_y x_2 if M applied to w halts, and
>>> q_0 w_M w ⊢* x_1 q_n x_2 if M applied to w does not halt
>>>
>>> The input to this machine is w_M plus the input string w. The
>>> conditions specified to the two final states make no mention
>>> whatsoever of w_M. They talk about *M* applied to w.
>>>
>>
>> By saying it that way people can be confused (the same way that Linz
>
> Saying it that way is how halt decider is *defined*. Not just by Linz,
> but by *everyone* who has ever discussed this problem.
>
> If you want to discuss the halting problem, this is the definition you
> must use.
>

If everyone "defines" that the halt decider is wrong when it correctly
reports what the actual behavior of its actual input would be then
everyone (besides me) is wrong.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7531&group=comp.ai.philosophy#7531

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 16:41:04 -0500
Date: Tue, 2 Nov 2021 16:41:01 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
intuition versus logic ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
<sls7ku$aom$1@dont-email.me> <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>
<sls97c$mj5$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sls97c$mj5$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com>
Lines: 47
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-S11dxM4ZL1ng3lZK1KS92N1zs/wjNz1Bw0X7DM9KpjL/NCUT4/Jh0ogaETrQqeNd3gx5/POXx1cdNsR!iW/FVbNiPVIAYziTzjRCFTV+u53KlT2ZJ80oqkYdQAxt+cJ/Y1uzXTN7JWP1SD7epu3z2RKCQj6e!hA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3707
 by: olcott - Tue, 2 Nov 2021 21:41 UTC

On 11/2/2021 4:05 PM, André G. Isaak wrote:
> On 2021-11-02 14:43, olcott wrote:
>
>> If everyone "defines" that the halt decider is wrong when it correctly
>> reports what the actual behavior of its actual input would be then
>> everyone (besides me) is wrong.
>
> The definition tells you what a halt decider *is*. It doesn't define it
> as 'wrong'. It defines what question it is supposed to answer.
>
> The input to a halt decider is a string. Strings don't *have* halting
> behaviour so your position above is entirely incoherent.
>

In computability theory, the halting problem is the problem of
determining, from a description of an arbitrary computer program and an
input, whether the program will finish running, or continue to run
forever. https://en.wikipedia.org/wiki/Halting_problem

A halt decider only need answer whether or not the correct simulation of
its input would ever reach a final state of this input by a simulating
halt decider.

In every case where the answer is "no" every encoding of any simulating
halt decider would correctly decide the halt status of this input as
"not halting".

> The string w_Ĥ w_Ĥ describes the computation where the Turing Machine Ĥ
> is applied to the string w_Ĥ. That computation halts. And it is the
> behaviour of that computation that a halting decider must report when
> given w_Ĥ w_Ĥ as an input BECAUSE THAT'S WHAT A HALT DECIDER IS DEFINED
> TO DO.
>
> Your claim that the "input" doesn't halt even though the actual machine
> does simply illustrates that you are clueless about what the actual
> halting problem is.
>
> André
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]

<OP-dnatHRdOUXBz8nZ2dnUU7-VnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7532&group=comp.ai.philosophy#7532

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr2.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 17:51:53 -0500
Date: Tue, 2 Nov 2021 17:51:51 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com> <874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com> <87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com> <87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com> <874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com> <87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com> <87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me> <sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com> <sls7ku$aom$1@dont-email.me> <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com> <sls97c$mj5$1@dont-email.me> <BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com> <slsbon$854$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slsbon$854$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <OP-dnatHRdOUXBz8nZ2dnUU7-VnNnZ2d@giganews.com>
Lines: 110
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vbNoVwXP3Av9cH08r6lknj4GCb0YrOavKtOUDxs9pl17yojB3EdufsTLoEkDGxwrP4itSZT9CuRuMsx!VvQSmGe//S+/g85I6dYoBDECyCIDwSohUFD4OTaqBbvgaEa+n6hAhcizwIRXgo1WngAaB3CgaCyj!hw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6459
 by: olcott - Tue, 2 Nov 2021 22:51 UTC

On 11/2/2021 4:49 PM, André G. Isaak wrote:
> On 2021-11-02 15:41, olcott wrote:
>> On 11/2/2021 4:05 PM, André G. Isaak wrote:
>>> On 2021-11-02 14:43, olcott wrote:
>>>
>>>> If everyone "defines" that the halt decider is wrong when it
>>>> correctly reports what the actual behavior of its actual input would
>>>> be then everyone (besides me) is wrong.
>>>
>>> The definition tells you what a halt decider *is*. It doesn't define
>>> it as 'wrong'. It defines what question it is supposed to answer.
>>>
>>> The input to a halt decider is a string. Strings don't *have* halting
>>> behaviour so your position above is entirely incoherent.
>>>
>>
>> In computability theory, the halting problem is the problem of
>> determining, from a description of an arbitrary computer program and
>> an input, whether the program will finish running, or continue to run
>> forever. https://en.wikipedia.org/wiki/Halting_problem
>
> The definition of 'halting problem' is what it is.
>
> Note that the above definition doesn't make any mentions of
> 'simulations' just as the more formal definition used by Linz's does not.
>
>> A halt decider only need answer whether or not the correct simulation
>> of its input would ever reach a final state of this input by a
>> simulating halt decider.
>
> A 'correct simulation', presumably, would be one that acts identically
> to the actual TM being simulated. That means that if the actual TM halts
> the simulation also must halt. Which means that your simulation is not a
> 'correct simulation'.
>

There are no freaking presumptions about it. As long as the simulation
of P(P) matches its x86 source code then the simulation is correct.

If you don't agree with this then you are either:
(a) A liar
(b) Stupid
(c) Clueless

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

A correct simulation of P on input P can be empirically validated by the
simulation of the first seven x86 instruction of P.

Begin Local Halt Decider Simulation at Machine Address:c36
machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

Because the simulation of P(P) matches its x86 source-code it is
necessarily correct and impossibly incorrect.

The only possibility for every encoding of simulating halt decider H is:

(a) H fails to abort its simulation (and thus fails to be a decider) and
the first seven instructions of P infinitely repeat in which case P
never reaches its final state of 0xc50.

(b) H aborts its simulation of P at some address of P between 0xc36 and
0xc41 in which case the input P fails to every reach its final state of
0xc50.

One the basis of the correct simulation of the x86 source-code of P(P)
we can see that it is utterly impossible for P to ever reach its final
state of 0xc50.

> If a simulation can have a different behaviour then the actual program,
> then that simulation can't be used to answer the question which a halt
> decider is supposed to answer.
>
> You really ought to consider a different line of 'work'. Have you
> thought of maybe inventing a perpetual motion machine or of squaring the
> circle? Maybe you'd have more luck with those.
>
> André
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]

<e5Cdnc0LRdRXexz8nZ2dnUU7-R_NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7533&group=comp.ai.philosophy#7533

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 20:32:58 -0500
Date: Tue, 2 Nov 2021 20:32:56 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
impossibly incorrect ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
<sls7ku$aom$1@dont-email.me> <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>
<sls97c$mj5$1@dont-email.me> <BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com>
<slsbon$854$1@dont-email.me> <OP-dnatHRdOUXBz8nZ2dnUU7-VnNnZ2d@giganews.com>
<slshor$f6s$1@dont-email.me> <UoidnfNTs8k7QRz8nZ2dnUU7-WednZ2d@giganews.com>
<slsnd6$aqe$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slsnd6$aqe$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <e5Cdnc0LRdRXexz8nZ2dnUU7-R_NnZ2d@giganews.com>
Lines: 178
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fn2WyrvMYJVuFFdGlP8DKoOkLGzKIadYFS3HxghTIX3pGWCDtVuBBvuqtZmOKkW5XOdFuVq/Wl5AZBF!qeyFZ12VHw3wQMYIjj9/o0+Bi5H/eMpNUcw84WOUvPH0MqFnTInKZay/Yc/4DwEDJUgXDSDJbDyS!kg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 9440
X-Received-Bytes: 9619
 by: olcott - Wed, 3 Nov 2021 01:32 UTC

On 11/2/2021 8:07 PM, André G. Isaak wrote:
> On 2021-11-02 18:49, olcott wrote:
>> On 11/2/2021 6:31 PM, André G. Isaak wrote:
>>> On 2021-11-02 16:51, olcott wrote:
>>>> On 11/2/2021 4:49 PM, André G. Isaak wrote:
>>>>> On 2021-11-02 15:41, olcott wrote:
>>>>>> On 11/2/2021 4:05 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-02 14:43, olcott wrote:
>>>>>>>
>>>>>>>> If everyone "defines" that the halt decider is wrong when it
>>>>>>>> correctly reports what the actual behavior of its actual input
>>>>>>>> would be then everyone (besides me) is wrong.
>>>>>>>
>>>>>>> The definition tells you what a halt decider *is*. It doesn't
>>>>>>> define it as 'wrong'. It defines what question it is supposed to
>>>>>>> answer.
>>>>>>>
>>>>>>> The input to a halt decider is a string. Strings don't *have*
>>>>>>> halting behaviour so your position above is entirely incoherent.
>>>>>>>
>>>>>>
>>>>>> In computability theory, the halting problem is the problem of
>>>>>> determining, from a description of an arbitrary computer program
>>>>>> and an input, whether the program will finish running, or continue
>>>>>> to run forever. https://en.wikipedia.org/wiki/Halting_problem
>>>>>
>>>>> The definition of 'halting problem' is what it is.
>>>>>
>>>>> Note that the above definition doesn't make any mentions of
>>>>> 'simulations' just as the more formal definition used by Linz's
>>>>> does not.
>>>>>
>>>>>> A halt decider only need answer whether or not the correct
>>>>>> simulation of its input would ever reach a final state of this
>>>>>> input by a simulating halt decider.
>>>>>
>>>>> A 'correct simulation', presumably, would be one that acts
>>>>> identically to the actual TM being simulated. That means that if
>>>>> the actual TM halts the simulation also must halt. Which means that
>>>>> your simulation is not a 'correct simulation'.
>>>>>
>>>>
>>>> There are no freaking presumptions about it. As long as the
>>>> simulation of P(P) matches its x86 source code then the simulation
>>>> is correct.
>>>
>>> I have no idea what it means for a simulation of P(P) to "match its
>>> x86 source code".
>>>
>>
>> When the simulator executes the instructions at
>> 0xc36, 0xc37, 0xc39, 0xc3c, 0xc3d, 0xc40, 0xc41
>> of the x86 source code of P, then the simulator
>> correctly simulated P(P).
>
> No. A simulator only 'correctly simulates' a machine when it accurately
> duplicates *all* of the behaviour of that machine. Part of the behaviour
> of P(P) is that it halts.
>

That is a stupid thing to say. The x86 emulator correctly emulates the
x86 instructions of P iff it emulates the actual x86 intructions of P
saying anything else is both pure bullshit and quite nutty.

>>>> _P()
>>>> [00000c36](01)  55          push ebp
>>>> [00000c37](02)  8bec        mov ebp,esp
>>>> [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
>>>> [00000c3c](01)  50          push eax
>>>> [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
>>>> [00000c40](01)  51          push ecx
>>>> [00000c41](05)  e820fdffff  call 00000966    // call H
>>>> [00000c46](03)  83c408      add esp,+08
>>>> [00000c49](02)  85c0        test eax,eax
>>>> [00000c4b](02)  7402        jz 00000c4f
>>>> [00000c4d](02)  ebfe        jmp 00000c4d
>>>> [00000c4f](01)  5d          pop ebp
>>>> [00000c50](01)  c3          ret
>>>> Size in bytes:(0027) [00000c50]
>>>>
>>>> A correct simulation of P on input P can be empirically validated by
>>>> the simulation of the first seven x86 instruction of P.
>>>>
>>>> Begin Local Halt Decider Simulation at Machine Address:c36
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00000c36][002117ca][002117ce] 55          push ebp
>>>> [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>>>> [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>>>> [00000c3c][002117c6][00000c36] 50          push eax       // push P
>>>> [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>>>> [00000c40][002117c2][00000c36] 51          push ecx       // push P
>>>> [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call
>>>> H(P,P)
>>>>
>>>> Because the simulation of P(P) matches its x86 source-code it is
>>>> necessarily correct and impossibly incorrect.
>>>>
>>>>
>>>> The only possibility for every encoding of simulating halt decider H
>>>> is:
>>>
>>>> (a) H fails to abort its simulation (and thus fails to be a decider)
>>>> and the first seven instructions of P infinitely repeat in which
>>>> case P never reaches its final state of 0xc50.
>>>>
>>>> (b) H aborts its simulation of P at some address of P between 0xc36
>>>> and 0xc41 in which case the input P fails to every reach its final
>>>> state of 0xc50.
>>>>
>>>> One the basis of the correct simulation of the x86 source-code of
>>>> P(P) we can see that it is utterly impossible for P to ever reach
>>>> its final state of 0xc50.
>>>
>>> Even if your argument above were sound, it is also *irrelevant* since
>>> the criterion which defines a 'halt decider' makes no mention about
>>> simulations, simulators or aborted simulations.
>>
>> Because the criteria does say by what-so-ever means, it includes
>> simulation.
>
> I never claimed otherwise.

You implied otherwise.

>
>>>
>>> If P(P) halts, then the correct answer to the question 'Does P(P)
>>> halt?' is 'yes'. And that's the question *by definition* which a halt
>>> decider must answer.
>>>
>>> André
>>>
>>
>> A halt decider only need answer whether or not the correct simulation
>> of its input would ever reach a final state of this input by a
>> simulating halt decider.
>
>
> No. A halt decider needs to answer the question which a halt decider is
> required to answer.

And a black cat <is> both black and a cat.

> A halt decider which takes w_M and w as its inputs
> must answer the question 'Does M halt on input w?' since that is how a
> halt decider is *defined*.
>

You keep screwing around with the point in the execution trace that counts.

> It doesn't matter whether you reach the answer by simulating or not. The
> question and the answer remain the same. P(P) halts,

You have to have the correct computation.
If we want to know if Bill robbed the liquor store and Bill Jones did
rob the liquor store it is not OK to put Bill Smith in jail on the basis
that it is true that Bill robbed the liquor store.

The input to H1(P,P) is computationally equivalent to P(P).
The input to H(P,P) is not computationally equivalent to P(P).

> so the answer to
> 'Does P(P) halt?', which is what a halt-decider is defined to answer, is
> 'yes'.
>
> Any halt-decider which answers otherwise is simply wrong.
>
> André
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]

<rMudnZ-NI_cOYxz8nZ2dnUU7-XnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7534&group=comp.ai.philosophy#7534

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Tue, 02 Nov 2021 22:14:27 -0500
Date: Tue, 2 Nov 2021 22:14:24 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
impossibly incorrect ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
<sls7ku$aom$1@dont-email.me> <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>
<sls97c$mj5$1@dont-email.me> <BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com>
<slsbon$854$1@dont-email.me> <OP-dnatHRdOUXBz8nZ2dnUU7-VnNnZ2d@giganews.com>
<slshor$f6s$1@dont-email.me> <UoidnfNTs8k7QRz8nZ2dnUU7-WednZ2d@giganews.com>
<slsnd6$aqe$1@dont-email.me> <e5Cdnc0LRdRXexz8nZ2dnUU7-R_NnZ2d@giganews.com>
<slss02$vah$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slss02$vah$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <rMudnZ-NI_cOYxz8nZ2dnUU7-XnNnZ2d@giganews.com>
Lines: 94
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-g2y0OhXhzNsNgfOVPTdkFM72V82ubbCJydDUrTpAUFcIs7ji6ivPGEQzoLchXqysDDMTNFIoh3DZQlq!HSl0b2YLSt86bOoBT4/uG9ECV1HCZgbkGgS/ynQ35770NqBHuZe3/UNhNhTVlPPL3c4vVrc3Z+k/!4g==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6338
 by: olcott - Wed, 3 Nov 2021 03:14 UTC

On 11/2/2021 9:26 PM, André G. Isaak wrote:
> On 2021-11-02 19:32, olcott wrote:
>> On 11/2/2021 8:07 PM, André G. Isaak wrote:
>>> On 2021-11-02 18:49, olcott wrote:
>>>> On 11/2/2021 6:31 PM, André G. Isaak wrote:
>>>>> On 2021-11-02 16:51, olcott wrote:
>>>>>> On 11/2/2021 4:49 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-02 15:41, olcott wrote:
>>>>>>>> On 11/2/2021 4:05 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-02 14:43, olcott wrote:
>>>>>>>>>
>>>>>>>>>> If everyone "defines" that the halt decider is wrong when it
>>>>>>>>>> correctly reports what the actual behavior of its actual input
>>>>>>>>>> would be then everyone (besides me) is wrong.
>>>>>>>>>
>>>>>>>>> The definition tells you what a halt decider *is*. It doesn't
>>>>>>>>> define it as 'wrong'. It defines what question it is supposed
>>>>>>>>> to answer.
>>>>>>>>>
>>>>>>>>> The input to a halt decider is a string. Strings don't *have*
>>>>>>>>> halting behaviour so your position above is entirely incoherent.
>>>>>>>>>
>>>>>>>>
>>>>>>>> In computability theory, the halting problem is the problem of
>>>>>>>> determining, from a description of an arbitrary computer program
>>>>>>>> and an input, whether the program will finish running, or
>>>>>>>> continue to run forever.
>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>
>>>>>>> The definition of 'halting problem' is what it is.
>>>>>>>
>>>>>>> Note that the above definition doesn't make any mentions of
>>>>>>> 'simulations' just as the more formal definition used by Linz's
>>>>>>> does not.
>>>>>>>
>>>>>>>> A halt decider only need answer whether or not the correct
>>>>>>>> simulation of its input would ever reach a final state of this
>>>>>>>> input by a simulating halt decider.
>>>>>>>
>>>>>>> A 'correct simulation', presumably, would be one that acts
>>>>>>> identically to the actual TM being simulated. That means that if
>>>>>>> the actual TM halts the simulation also must halt. Which means
>>>>>>> that your simulation is not a 'correct simulation'.
>>>>>>>
>>>>>>
>>>>>> There are no freaking presumptions about it. As long as the
>>>>>> simulation of P(P) matches its x86 source code then the simulation
>>>>>> is correct.
>>>>>
>>>>> I have no idea what it means for a simulation of P(P) to "match its
>>>>> x86 source code".
>>>>>
>>>>
>>>> When the simulator executes the instructions at
>>>> 0xc36, 0xc37, 0xc39, 0xc3c, 0xc3d, 0xc40, 0xc41
>>>> of the x86 source code of P, then the simulator
>>>> correctly simulated P(P).
>>>
>>> No. A simulator only 'correctly simulates' a machine when it
>>> accurately duplicates *all* of the behaviour of that machine. Part of
>>> the behaviour of P(P) is that it halts.
>>>
>>
>> That is a stupid thing to say. The x86 emulator correctly emulates the
>> x86 instructions of P iff it emulates the actual x86 intructions of P
>> saying anything else is both pure bullshit and quite nutty.
>
> That's a nonsensical claim. If it correctly emulates all the
> instructions then it should have identical behaviour. That includes
> whether it halts or not.

Maybe you don't understand the x86 language well enough to ever
understand what I am saying.

While H continues to simulate P these first seven instructions of P
continue to repeat. Do you understand that?

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]

<3JWdnce5TrR1Nh_8nZ2dnUU7-bnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7536&group=comp.ai.philosophy#7536

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 10:34:00 -0500
Date: Wed, 3 Nov 2021 10:34:00 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
impossibly incorrect ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
<sls7ku$aom$1@dont-email.me> <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>
<sls97c$mj5$1@dont-email.me> <BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com>
<slsbon$854$1@dont-email.me> <OP-dnatHRdOUXBz8nZ2dnUU7-VnNnZ2d@giganews.com>
<slshor$f6s$1@dont-email.me> <UoidnfNTs8k7QRz8nZ2dnUU7-WednZ2d@giganews.com>
<slsnd6$aqe$1@dont-email.me> <e5Cdnc0LRdRXexz8nZ2dnUU7-R_NnZ2d@giganews.com>
<slss02$vah$1@dont-email.me> <rMudnZ-NI_cOYxz8nZ2dnUU7-XnNnZ2d@giganews.com>
<slsvo7$iu0$1@dont-email.me> <slt22a$g91$1@gioia.aioe.org>
<slu7qp$16qj$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slu7qp$16qj$1@gioia.aioe.org>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <3JWdnce5TrR1Nh_8nZ2dnUU7-bnNnZ2d@giganews.com>
Lines: 194
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-runqj+sRKC6mrDrf9CLEt61yF4YWriOgfb9EMJ0Ua9Xq54AOXn2TvUKv9KAa5EZuRlLyBv2RpEeOYEE!h7ZWffWyfx28SLwiimNDW8BPBWbSLvs78ifo+4FU7im7a7wvEuZBnG+rBxhYJILj3Uj+BtecaF9S!UA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 11188
 by: olcott - Wed, 3 Nov 2021 15:34 UTC

On 11/3/2021 9:54 AM, Mike Terry wrote:
> On 03/11/2021 04:09, Mike Terry wrote:
>> On 03/11/2021 03:30, André G. Isaak wrote:
>>> On 2021-11-02 21:14, olcott wrote:
>>>> On 11/2/2021 9:26 PM, André G. Isaak wrote:
>>>>> On 2021-11-02 19:32, olcott wrote:
>>>>>> On 11/2/2021 8:07 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-02 18:49, olcott wrote:
>>>>>>>> On 11/2/2021 6:31 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-02 16:51, olcott wrote:
>>>>>>>>>> On 11/2/2021 4:49 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-11-02 15:41, olcott wrote:
>>>>>>>>>>>> On 11/2/2021 4:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-11-02 14:43, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> If everyone "defines" that the halt decider is wrong when
>>>>>>>>>>>>>> it correctly reports what the actual behavior of its
>>>>>>>>>>>>>> actual input would be then everyone (besides me) is wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The definition tells you what a halt decider *is*. It
>>>>>>>>>>>>> doesn't define it as 'wrong'. It defines what question it
>>>>>>>>>>>>> is supposed to answer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The input to a halt decider is a string. Strings don't
>>>>>>>>>>>>> *have* halting behaviour so your position above is entirely
>>>>>>>>>>>>> incoherent.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> In computability theory, the halting problem is the problem
>>>>>>>>>>>> of determining, from a description of an arbitrary computer
>>>>>>>>>>>> program and an input, whether the program will finish
>>>>>>>>>>>> running, or continue to run forever.
>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>
>>>>>>>>>>> The definition of 'halting problem' is what it is.
>>>>>>>>>>>
>>>>>>>>>>> Note that the above definition doesn't make any mentions of
>>>>>>>>>>> 'simulations' just as the more formal definition used by
>>>>>>>>>>> Linz's does not.
>>>>>>>>>>>
>>>>>>>>>>>> A halt decider only need answer whether or not the correct
>>>>>>>>>>>> simulation of its input would ever reach a final state of
>>>>>>>>>>>> this input by a simulating halt decider.
>>>>>>>>>>>
>>>>>>>>>>> A 'correct simulation', presumably, would be one that acts
>>>>>>>>>>> identically to the actual TM being simulated. That means that
>>>>>>>>>>> if the actual TM halts the simulation also must halt. Which
>>>>>>>>>>> means that your simulation is not a 'correct simulation'.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> There are no freaking presumptions about it. As long as the
>>>>>>>>>> simulation of P(P) matches its x86 source code then the
>>>>>>>>>> simulation is correct.
>>>>>>>>>
>>>>>>>>> I have no idea what it means for a simulation of P(P) to "match
>>>>>>>>> its x86 source code".
>>>>>>>>>
>>>>>>>>
>>>>>>>> When the simulator executes the instructions at
>>>>>>>> 0xc36, 0xc37, 0xc39, 0xc3c, 0xc3d, 0xc40, 0xc41
>>>>>>>> of the x86 source code of P, then the simulator
>>>>>>>> correctly simulated P(P).
>>>>>>>
>>>>>>> No. A simulator only 'correctly simulates' a machine when it
>>>>>>> accurately duplicates *all* of the behaviour of that machine.
>>>>>>> Part of the behaviour of P(P) is that it halts.
>>>>>>>
>>>>>>
>>>>>> That is a stupid thing to say. The x86 emulator correctly emulates
>>>>>> the x86 instructions of P iff it emulates the actual x86
>>>>>> intructions of P saying anything else is both pure bullshit and
>>>>>> quite nutty.
>>>>>
>>>>> That's a nonsensical claim. If it correctly emulates all the
>>>>> instructions then it should have identical behaviour. That includes
>>>>> whether it halts or not.
>>>>
>>>> Maybe you don't understand the x86 language well enough to ever
>>>> understand what I am saying.
>>>>
>>>> While H continues to simulate P these first seven instructions of P
>>>> continue to repeat. Do you understand that?
>>>
>>> Which is irrelevant to the halting problem which asks whether P(P)
>>> halts? Does it? Yes. Ergo the only correct for H(P, P) to give is
>>> 'true'. *Nothing* apart from the actual behaviour of P(P) is relevant
>>> to determining what the correct answer to this question is, so
>>> there's not even any point in providing all your meaningless traces.
>>>
>>> The correct answer to H(P, P) is determined by the actual behaviour
>>> of P(P). We know the actual behaviour of P(P). So there's absolutely
>>> no reason to consider anything else.
>>>
>>> And you conveniently ignored all the questions which I asked.
>>>
>>> What does the input to H(P, P) represent if not P(P)?
>>>
>>> How can the inputs to H1(P, P) and H(P, P) represent different things
>>> given that they are the *same* input?
>>
>> My suspicion (difficult to confirm) is still that in both those cases,
>> PO is looking at the same computation.  It's simply that H and H1, in
>> examining the identical execution traces, behave differently because
>> they take their own machine code address and use that in interpreting
>> the instruction trace.
>>
>> So e.g. H uses its address to exclude certain parts of the trace it
>> examines, and consequently INCORRECTLY decides it is seeing infinite
>> recursion.  H1 excludes a different address range, so it doesn't see
>> infinite recursion and so the simulation continues FURTHER than H
>> continues it, and in fact with H1 the simulation proceeds right up to
>> the point where it reaches its halt state, so H1 give the correct
>> answer.  [I'd guess H1 works because it is seeing the conditional
>> branch instructions that H deliberately ignores, and so his unsound
>> recursion test does not match.]
>>
>> I bet if we looked at the actual traces that H and H1 are producing,
>
> Correction - what I meant to say here is "actual traces that H and H1
> are EXAMINING".
>
> Obviously the traces of H(P,P) and H1(P,P) [including the traces of the
> outer emulations of H, H1 themselves] will be different, because H and
> H1 addresses will be different if nothing else.
>
> That's a trivial point, but seems to be a constant point of
> miscomunication between PO and others.  I reckon that when PO says
> "computations H(P,P) and H1(P,P)" he is intending to say "the traces of
> the SIMULATIONS of P(P) within H and H1", or similar.  [And if I'm right
> above, those are NOT different, other than that H1 simulates FURTHER
> than H, and so gets to observe the simulation halting.  Nothing to do
> with the presence of mysterious PSR!.]
>
> Mike.
>

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]


Click here to read the complete article
Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]

<x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7537&group=comp.ai.philosophy#7537

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 10:47:15 -0500
Date: Wed, 3 Nov 2021 10:47:14 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
updated criterion ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87zgqmgc6y.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
Lines: 78
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JohCMnB+nesSTnD29/1zMCh1l4BlvX4y1TR6Up9564h0HTdrAiG2WibT075lTxQpg9E+D06CXVtZYjG!dXIh7o6mMVIXI+CupwgxlQ+ew6cGDgyhhEghxg0pVrWkgRUyJtOpGByOJHApfjSGxgZEKaqOeoNH!rA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 5066
 by: olcott - Wed, 3 Nov 2021 15:47 UTC

On 11/2/2021 10:17 PM, Ben Bacarisse wrote:
> olcott <polcott2@gmail.com> writes:
>
>> On 11/2/2021 12:25 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 11/2/2021 11:15 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>> As long as H(P,P)==0 is correct none of my other "errors" are of any
>>>>>> consequence what-so-ever.
>>>>>
>>>>> That's why I said one error really count: H(P,P)==0 is not correct
>>>>> because P(P) halts. How is it that you can keep ignoring this?
>>>>
>>>> It is a verified fact that for every possible (abort / do not abort)
>>>> behavior of every possible encoding of simulating halt decider H that
>>>> the input to H(P,P) never reaches its final state.
>>> H(P,P)==0 is wrong because P(P) halts. You keep trying to explain some
>>> other decision problem that you think H is getting right. For the
>>> halting problem -- the one you've been "studying" for more than 14 years
>>> -- H(P,P)==0 is only correct if P(P) does not halt and you've told us
>>> that is does.
>>>
>>>> It is like I am telling there are no integers between 1 and 2 and you
>>>> just don't believe it.
>>> No, its like you are tell me that H(P,P)==false is the right answer from
>>> a halt decider when P(P) is a halting computation. In fact it's very
>>> much like that. Almost exactly like that in fact.
>>>
>>>> It seems to be intuitively true that H(P,P) should report that its
>>>> input halts because P(P) halts.
>>> No. I have no intuition about what you even mean because inputs don't
>>> do anything. What is true by definition (no intuition required) is that
>>> H(P,P) should be false only if P(P) does not halt.
>>>
>>>> This intuition
>>> I don't have that intuition. What "the input" does is meaningless.
>>
>> Every halt decider is ONLY tasked with determining the behavior of its
>> input.
>
> No. Every halt decider is tasked with determining the behaviour of the
> computation represented by its input. That's why H(P,P)==0 is wrong.
> The arguments in that call represent the halting computation P(P).
>

THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
A halt decider only need answer whether or not the correct pure
simulation of its input would ever reach a final state of this input by
a simulating halt decider.

This addresses two issues, it focuses analysis on the correct point in
the execution trace.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
It does not matter whether or not the halt decider at Ĥ.qx halts or not
the only thing that matters is whether or not the simulation of the
input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ever reaches a final state.

It acknowledges that inputs themselves only have behavior while they are
simulated.

>> That you say otherwise is very stupid.
>
> I say otherwise because I know what the halting problem is, and because
> I want to be careful about the details. You are deliberately not
> talking about what the input represents because you know H is wrong
> about that computation. This shift in wording is all you have left
> after 14 years of being wrong about halting.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<Ps6dnR7HhMh3Mh_8nZ2dnUU7-LHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7538&group=comp.ai.philosophy#7538

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 10:51:06 -0500
Date: Wed, 3 Nov 2021 10:50:59 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
intuition versus logic ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <slro2c$87g$2@dont-email.me>
<87sfweo4ze.fsf@bsb.me.uk> <slrsh9$kn8$1@dont-email.me>
<87wnlqgc2h.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87wnlqgc2h.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Ps6dnR7HhMh3Mh_8nZ2dnUU7-LHNnZ2d@giganews.com>
Lines: 61
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-leXDtHTQ4T7zE07kacR8SSZcYdIPombepLsBDNnax3gXkb3yqq2McZSRbEOS3dKFNvDWg57jpATzy3p!2GtLq9s/xO5FHfjwnlE2pSc6wy6APuEOlFdquFvpOKzJPdCp4L0XrNdeaVvPMNxR2eAMeFxJNJ7w!jA==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3814
 by: olcott - Wed, 3 Nov 2021 15:50 UTC

On 11/2/2021 10:20 PM, Ben Bacarisse wrote:
> olcott <polcott2@gmail.com> writes:
>
>> On 11/2/2021 12:13 PM, Ben Bacarisse wrote:
>>> olcott <polcott2@gmail.com> writes:
>>>
>>>> On 11/2/2021 10:10 AM, Ben Bacarisse wrote:
>>>
>>>>> You want me to get sucked into discussing your other errors, but really
>>>>> only one counts: H(P,P) == false is the wrong answer if P(P) halts.
>>>>>
>>>> As long as H(P,P)==0 is correct none of my other "errors" are of any
>>>> consequence what-so-ever.
>>> Only one error really matters, and that's the fact that H(P,P)==0 is not
>>> correct if P(P) halts,
>>
>> As long as the input to H(P,P) cannot possibly halt for every possible
>> encoding of simulating halt decider H then H(P,P)==0 can't possibly be
>> incorrect NO MATTER WHAT.
>
> Whether H(P,P)==0 is correct is determined by what P(P) does, and since
> P(P) halts, H(P,P)==0 is wrong.
>

THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
A halt decider only need answer whether or not the correct pure
simulation of its input would ever reach a final state of this input by
a simulating halt decider.

This addresses two issues, it focuses analysis on the correct point in
the execution trace.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
It does not matter whether or not the halt decider at Ĥ.qx halts or not
the only thing that matters is whether or not the simulation of the
input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ever reaches a final state.

It acknowledges that inputs themselves only have behavior while they are
simulated.

It does not matter what P(P) does it matters what the simulated input to
H(P,P) does.

H1(P,P) is computationally equivalent to P(P).
H(P,P) is not computationally equivalent to H1(P,P) or P(P).

>> If we have a black cat then it is utterly impossible that we do not
>> have a cat.
>
> We have a hating computation, P(P), and an H that is wrong about it. I
> don't know what all this nonsense about cats is intended to show.
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]

<ILGdnVv-3NrIKB_8nZ2dnUU7-YfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7539&group=comp.ai.philosophy#7539

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 11:14:13 -0500
Date: Wed, 3 Nov 2021 11:14:12 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
updated criterion ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk> <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
<slubnd$s6d$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slubnd$s6d$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ILGdnVv-3NrIKB_8nZ2dnUU7-YfNnZ2d@giganews.com>
Lines: 38
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-FJlcdL6Gi4NUTmDvRWMtS8FiiluPP0B6fJjJ5U5RR2Skv0n0mnCzGzaoQC1oAsk+MtON9l+WCz7Z00g!KU5DGx08oc6XMfxgHI1cnbg2HeJ2iqrvZzicEZ3n3BYBTxRCcEbgneuhX9SiQp6uIw8jl8j9RHJW!kg==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3244
 by: olcott - Wed, 3 Nov 2021 16:14 UTC

On 11/3/2021 11:00 AM, André G. Isaak wrote:
> On 2021-11-03 09:47, olcott wrote:
>
>> THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
>> A halt decider only need answer whether or not the correct pure
>> simulation of its input would ever reach a final state of this input
>> by a simulating halt decider.
>
> The halting problem already defines what the criterion used by a halt
> decider must be. You don't get to update it if that's the problem you
> want to work on.
>
> André
>

No one here seems capable of understanding is that when a halt decider
does correctly decide the halt status of its input then its input has
had its halt status correctly decided.

Even Linz got confused about this.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
It does not matter whether or not the halt decider at Ĥ.qx halts or not
the only thing that matters is whether or not the simulation of the
input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ever reaches a final state.

The mistake is just like putting Bill Smith in jail for robbing a liquor
store because Bill Jones did Rob a liquor store.

As long as a halt decider does correctly decide the halt status of its
input nothing else in the universe can show that the halt decider is
incorrect.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]

<Po2dnUVqrOdIKx_8nZ2dnUU7-YPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7540&group=comp.ai.philosophy#7540

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 11:20:37 -0500
Date: Wed, 3 Nov 2021 11:20:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
impossibly incorrect ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<sls5k8$reo$1@dont-email.me> <eM-dnXBYuszuAxz8nZ2dnUU7-W3NnZ2d@giganews.com>
<sls7ku$aom$1@dont-email.me> <GOOdndF6GPhiPxz8nZ2dnUU7-R2dnZ2d@giganews.com>
<sls97c$mj5$1@dont-email.me> <BNednUpXj6vtLRz8nZ2dnUU7-WXNnZ2d@giganews.com>
<slsbon$854$1@dont-email.me> <OP-dnatHRdOUXBz8nZ2dnUU7-VnNnZ2d@giganews.com>
<slshor$f6s$1@dont-email.me> <UoidnfNTs8k7QRz8nZ2dnUU7-WednZ2d@giganews.com>
<slsnd6$aqe$1@dont-email.me> <e5Cdnc0LRdRXexz8nZ2dnUU7-R_NnZ2d@giganews.com>
<slss02$vah$1@dont-email.me> <rMudnZ-NI_cOYxz8nZ2dnUU7-XnNnZ2d@giganews.com>
<slsvo7$iu0$1@dont-email.me> <pqadnbWVhZbfPB_8nZ2dnUU7-YmdnZ2d@giganews.com>
<sluaa3$jaa$1@dont-email.me> <Ps6dnRnHhMgNLR_8nZ2dnUU7-LGdnZ2d@giganews.com>
<sluc2j$pi$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sluc2j$pi$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Po2dnUVqrOdIKx_8nZ2dnUU7-YPNnZ2d@giganews.com>
Lines: 160
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-umyyowVxjoHComCWz0bHsv44pVeKpxhYqlKc6g9qpTi5N/pNJZ6w4/nAbjlYUjeWtSHG+OR6NyqZGmg!Q4Zs2GW0kShylfn0fD09bDKqHMzjPNdbDIoH/b+9jnermKiCsd8tRtzw59wiVEgc1p/PoV+iJoA2!bw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 9350
 by: olcott - Wed, 3 Nov 2021 16:20 UTC

On 11/3/2021 11:06 AM, André G. Isaak wrote:
> On 2021-11-03 09:53, olcott wrote:
>> On 11/3/2021 10:36 AM, André G. Isaak wrote:
>>> On 2021-11-03 08:48, olcott wrote:
>>>> On 11/2/2021 10:30 PM, André G. Isaak wrote:
>>>>> On 2021-11-02 21:14, olcott wrote:
>>>>>> On 11/2/2021 9:26 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-02 19:32, olcott wrote:
>>>>>>>> On 11/2/2021 8:07 PM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-02 18:49, olcott wrote:
>>>>>>>>>> On 11/2/2021 6:31 PM, André G. Isaak wrote:
>>>>>>>>>>> On 2021-11-02 16:51, olcott wrote:
>>>>>>>>>>>> On 11/2/2021 4:49 PM, André G. Isaak wrote:
>>>>>>>>>>>>> On 2021-11-02 15:41, olcott wrote:
>>>>>>>>>>>>>> On 11/2/2021 4:05 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2021-11-02 14:43, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If everyone "defines" that the halt decider is wrong
>>>>>>>>>>>>>>>> when it correctly reports what the actual behavior of
>>>>>>>>>>>>>>>> its actual input would be then everyone (besides me) is
>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The definition tells you what a halt decider *is*. It
>>>>>>>>>>>>>>> doesn't define it as 'wrong'. It defines what question it
>>>>>>>>>>>>>>> is supposed to answer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The input to a halt decider is a string. Strings don't
>>>>>>>>>>>>>>> *have* halting behaviour so your position above is
>>>>>>>>>>>>>>> entirely incoherent.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> In computability theory, the halting problem is the
>>>>>>>>>>>>>> problem of determining, from a description of an arbitrary
>>>>>>>>>>>>>> computer program and an input, whether the program will
>>>>>>>>>>>>>> finish running, or continue to run forever.
>>>>>>>>>>>>>> https://en.wikipedia.org/wiki/Halting_problem
>>>>>>>>>>>>>
>>>>>>>>>>>>> The definition of 'halting problem' is what it is.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Note that the above definition doesn't make any mentions of
>>>>>>>>>>>>> 'simulations' just as the more formal definition used by
>>>>>>>>>>>>> Linz's does not.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> A halt decider only need answer whether or not the correct
>>>>>>>>>>>>>> simulation of its input would ever reach a final state of
>>>>>>>>>>>>>> this input by a simulating halt decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A 'correct simulation', presumably, would be one that acts
>>>>>>>>>>>>> identically to the actual TM being simulated. That means
>>>>>>>>>>>>> that if the actual TM halts the simulation also must halt.
>>>>>>>>>>>>> Which means that your simulation is not a 'correct
>>>>>>>>>>>>> simulation'.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> There are no freaking presumptions about it. As long as the
>>>>>>>>>>>> simulation of P(P) matches its x86 source code then the
>>>>>>>>>>>> simulation is correct.
>>>>>>>>>>>
>>>>>>>>>>> I have no idea what it means for a simulation of P(P) to
>>>>>>>>>>> "match its x86 source code".
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When the simulator executes the instructions at
>>>>>>>>>> 0xc36, 0xc37, 0xc39, 0xc3c, 0xc3d, 0xc40, 0xc41
>>>>>>>>>> of the x86 source code of P, then the simulator
>>>>>>>>>> correctly simulated P(P).
>>>>>>>>>
>>>>>>>>> No. A simulator only 'correctly simulates' a machine when it
>>>>>>>>> accurately duplicates *all* of the behaviour of that machine.
>>>>>>>>> Part of the behaviour of P(P) is that it halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That is a stupid thing to say. The x86 emulator correctly
>>>>>>>> emulates the x86 instructions of P iff it emulates the actual
>>>>>>>> x86 intructions of P saying anything else is both pure bullshit
>>>>>>>> and quite nutty.
>>>>>>>
>>>>>>> That's a nonsensical claim. If it correctly emulates all the
>>>>>>> instructions then it should have identical behaviour. That
>>>>>>> includes whether it halts or not.
>>>>>>
>>>>>> Maybe you don't understand the x86 language well enough to ever
>>>>>> understand what I am saying.
>>>>>>
>>>>>> While H continues to simulate P these first seven instructions of
>>>>>> P continue to repeat. Do you understand that?
>>>>>
>>>>> Which is irrelevant to the halting problem
>>>>
>>>> I will not speak with you until you answer.
>>>
>>> Whether it does or does not repeat cannot be determined from this
>>> trace because you omit the instructions from the subroutine from your
>>> trace.
>>>
>>
>> Begin Local Halt Decider Simulation at Machine Address:c36
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00000c36][002117ca][002117ce] 55          push ebp
>> [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>> [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>> [00000c3c][002117c6][00000c36] 50          push eax       // push P
>> [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>> [00000c40][002117c2][00000c36] 51          push ecx       // push P
>> [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
>>
>> When it is given that H is a pure simulator of its input can you
>> comprhend that the above seven lines infinitely repeat?
>
> Nothing in the above seven lines indicates that they would repeat since
> there is no instruction there which branches back to c36.
>

If you look in the stack data column in the // push P rows
you will see that H is being called with 0xc36

Because I already told you to assume the line c41 of P calls
H as a pure simulator. It already says on lines c3c and c40
that P is being pushed onto the stack.

When P calls H with itself as input on c41 and H is only a pure
simulator of its input can you see that these first seven lines would
infinitely repeat?

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]


Click here to read the complete article
Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]

<ivCdnY3glPdlKh_8nZ2dnUU7-QPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7541&group=comp.ai.philosophy#7541

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 11:25:28 -0500
Date: Wed, 3 Nov 2021 11:25:27 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
updated criterion ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk> <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
<874k8tgqpw.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <874k8tgqpw.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <ivCdnY3glPdlKh_8nZ2dnUU7-QPNnZ2d@giganews.com>
Lines: 35
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ex23sji3Y4092LFvlM8VUQvCIKOagWSqUbsgJ2W2C9+5m3DFgOAfJihTu9mKGcfH+cSWm81ICQTXGuz!5AKitohO4AqghsVNIvaR928B7jZ2GCa+ZhZiJdCdDjoEUd3qO9MRlACUObg3qQDM1KxBbRejsFMF!6w==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3114
 by: olcott - Wed, 3 Nov 2021 16:25 UTC

On 11/3/2021 11:15 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/2/2021 10:17 PM, Ben Bacarisse wrote:
>>> olcott <polcott2@gmail.com> writes:
>
>>>> Every halt decider is ONLY tasked with determining the behavior of its
>>>> input.
>>>
>>> No. Every halt decider is tasked with determining the behaviour of the
>>> computation represented by its input. That's why H(P,P)==0 is wrong.
>>> The arguments in that call represent the halting computation P(P).
>>
>> THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
>> A halt decider only need answer whether or not the correct pure
>> simulation of its input would ever reach a final state of this input
>> by a simulating halt decider.
>
> The halting problem is already defined, thank you. H(P,P) == false is
> wrong because P(P) halts.
>

So in other words when H correctly determines that its input never
reaches its final state the fact that some other entirely different
computation does reach its final state proves that H is wrong?

H1(P,P) is computationally equivalent to P(P)
H(P,P) is NOT computationally equivalent to either P(P) or H1(P,P).

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]

<ivCdnYzglPeiJR_8nZ2dnUU7-QOdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7542&group=comp.ai.philosophy#7542

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 11:26:39 -0500
Date: Wed, 3 Nov 2021 11:26:39 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
intuition versus logic ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <slro2c$87g$2@dont-email.me>
<87sfweo4ze.fsf@bsb.me.uk> <slrsh9$kn8$1@dont-email.me>
<87wnlqgc2h.fsf@bsb.me.uk> <Ps6dnR7HhMh3Mh_8nZ2dnUU7-LHNnZ2d@giganews.com>
<87y265fc1a.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87y265fc1a.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <ivCdnYzglPeiJR_8nZ2dnUU7-QOdnZ2d@giganews.com>
Lines: 49
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WlI3jvDN+qY204TXi3mq6CBrIcWb9vR6ZMbAIMzvYxsxmxqfrncUT2wwX73TQZZIERfzcupcQQNKB8P!jKVc+Pvw4LcmAo0N8aK6qHXj4XUila2jHetm+N9uu+WhyYo6EEUc657fVAj3vN4z5hXPinxlegkM!gw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3634
 by: olcott - Wed, 3 Nov 2021 16:26 UTC

On 11/3/2021 11:18 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 11/2/2021 10:20 PM, Ben Bacarisse wrote:
>>> olcott <polcott2@gmail.com> writes:
>>>
>>>> On 11/2/2021 12:13 PM, Ben Bacarisse wrote:
>>>>> olcott <polcott2@gmail.com> writes:
>>>>>
>>>>>> On 11/2/2021 10:10 AM, Ben Bacarisse wrote:
>>>>>
>>>>>>> You want me to get sucked into discussing your other errors, but really
>>>>>>> only one counts: H(P,P) == false is the wrong answer if P(P) halts.
>>>>>>>
>>>>>> As long as H(P,P)==0 is correct none of my other "errors" are of any
>>>>>> consequence what-so-ever.
>>>>> Only one error really matters, and that's the fact that H(P,P)==0 is not
>>>>> correct if P(P) halts,
>>>>
>>>> As long as the input to H(P,P) cannot possibly halt for every possible
>>>> encoding of simulating halt decider H then H(P,P)==0 can't possibly be
>>>> incorrect NO MATTER WHAT.
>>> Whether H(P,P)==0 is correct is determined by what P(P) does, and since
>>> P(P) halts, H(P,P)==0 is wrong.
>>
>> THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
>> A halt decider only need answer whether or not the correct pure
>> simulation of its input would ever reach a final state of this input
>> by a simulating halt decider.
>
> We could problem just have one sub-thread about this. What I said both
> above and in my other reply still applied no matter how many times you
> re-write your criterion.
>

So in other words when H correctly determines that its input never
reaches its final state the fact that some other entirely different
computation does reach its final state proves that H is wrong?

H1(P,P) is computationally equivalent to P(P)
H(P,P) is NOT computationally equivalent to either P(P) or H1(P,P).

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ][ Linz mistake ]

<qZGdnZcdufJMJB_8nZ2dnUU7-IHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7543&group=comp.ai.philosophy#7543

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 11:33:21 -0500
Date: Wed, 3 Nov 2021 11:33:20 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
updated criterion ][ Linz mistake ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk> <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
<slubnd$s6d$1@dont-email.me> <ILGdnVv-3NrIKB_8nZ2dnUU7-YfNnZ2d@giganews.com>
<87sfwdfbpo.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87sfwdfbpo.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qZGdnZcdufJMJB_8nZ2dnUU7-IHNnZ2d@giganews.com>
Lines: 36
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fNYl7T6R6smnx2JxP4ccLnHIBiPSrYl3pMDp32u25cCHejArakoQBl3IKkFe8JFRi8oYygOpq1DyOPo!JB1cgeBydN0DbvCgyrLHPb30tX+O6dT8U8HjCsrSKMlajleuH9qZbWF7GLvubYiXf2FU1eUWGuGH!Xw==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 3256
 by: olcott - Wed, 3 Nov 2021 16:33 UTC

On 11/3/2021 11:25 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> No one here seems capable of understanding is that when a halt decider
>> does correctly decide the halt status of its input then its input has
>> had its halt status correctly decided.
>
> Don't be silly. No one disputes that (thought the wording is poor).
> The only disagreement is on what the correct answer is. Since P(P)
> halts and H(P,P) == false, H is not deciding correctly.
>

THE MOST RECENT UPDATE TO THE CRITERION MEASURE
A halt decider only need answer whether or not the correct pure
simulation of its input would ever reach a final state of this input by
a simulating halt decider.

Even Linz got confused about this:

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

It does not matter whether or not the halt decider at Ĥ.qx halts or not
the only thing that matters is whether or not the simulation of the
input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ever reaches a final state.

Top of page 320
https://www.liarparadox.org/Peter_Linz_HP_315-320.pdf

Linz believes that when Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn because its input never
halts this is nonsense because Ĥ does halt.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]

<7I6dndlGh-80Th_8nZ2dnUU7-YvNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7544&group=comp.ai.philosophy#7544

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 13:23:37 -0500
Date: Wed, 3 Nov 2021 13:23:36 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
updated criterion ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk> <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
<slubnd$s6d$1@dont-email.me> <ILGdnVv-3NrIKB_8nZ2dnUU7-YfNnZ2d@giganews.com>
<slufo0$t8l$1@dont-email.me> <5Z6dnZzsq4ApWR_8nZ2dnUU7-eGdnZ2d@giganews.com>
<sluhq6$dsk$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sluhq6$dsk$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <7I6dndlGh-80Th_8nZ2dnUU7-YvNnZ2d@giganews.com>
Lines: 56
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rPfEFgf8NormUFBmixJ+TwhsVr/z466fHFejhWkh5kXQTsa1I13iZStP8MQJZVUVKyFzW/xG6dNNICY!UMfEOzM/Cnj/JhbJAsryYIiPXtmJyTxFT1iOPDVDARrcyRnjGzyCltNQ8Ppr96arGCZ0eKNgScW1!aQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4094
 by: olcott - Wed, 3 Nov 2021 18:23 UTC

On 11/3/2021 12:44 PM, André G. Isaak wrote:
> On 2021-11-03 11:19, olcott wrote:
>> On 11/3/2021 12:09 PM, André G. Isaak wrote:
>>> On 2021-11-03 10:14, olcott wrote:
>>>> On 11/3/2021 11:00 AM, André G. Isaak wrote:
>>>>> On 2021-11-03 09:47, olcott wrote:
>>>>>
>>>>>> THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
>>>>>> A halt decider only need answer whether or not the correct pure
>>>>>> simulation of its input would ever reach a final state of this
>>>>>> input by a simulating halt decider.
>>>>>
>>>>> The halting problem already defines what the criterion used by a
>>>>> halt decider must be. You don't get to update it if that's the
>>>>> problem you want to work on.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> No one here seems capable of understanding is that when a halt
>>>> decider does correctly decide the halt status of its input then its
>>>> input has had its halt status correctly decided.
>>>
>>> Right. And since yours doesn't correctly decide the halt status of
>>> its input then its input has not had its halt status correctly decided.
>>>
>>
>> The only criteria for correctly deciding the halt status of the actual
>> input is whether or not the correct pure simulation of this input
>> would ever reach a final state.
>>
>> Every other criteria changes the subject to an entirely different
>> comutation.
>
>
> Both 'halting problem' and 'halt decider' were defined before you were
> born by people who actually UNDERSTOOD the topic.
>
> The definitions of these things are precise, unambiguous, and clearly
> indicate the actual criterion which a halt decider must use in making
> its decision. That criterion makes no reference to pure simulations. It
> refers only to whether the computation represented by the input string
> halts.
>

It is impossible for any halt decider to be incorrect when the correct
pure simulation of its input never halts and it reports not halting.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]

<VY2dnSq8-uQhYR_8nZ2dnUU7-cHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7545&group=comp.ai.philosophy#7545

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 16:18:52 -0500
Date: Wed, 3 Nov 2021 16:18:51 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
updated criterion ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk> <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
<slubnd$s6d$1@dont-email.me> <ILGdnVv-3NrIKB_8nZ2dnUU7-YfNnZ2d@giganews.com>
<slufo0$t8l$1@dont-email.me> <5Z6dnZzsq4ApWR_8nZ2dnUU7-eGdnZ2d@giganews.com>
<sluhq6$dsk$1@dont-email.me> <7I6dndlGh-80Th_8nZ2dnUU7-YvNnZ2d@giganews.com>
<slumbk$iqu$1@dont-email.me> <C86dnR0hvLVZdx_8nZ2dnUU78TXNnZ2d@giganews.com>
<slutej$a29$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slutej$a29$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <VY2dnSq8-uQhYR_8nZ2dnUU7-cHNnZ2d@giganews.com>
Lines: 105
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-78Wn82v9p+GnNjOUP40FaNtHJEqAlugsHikP7vY1WXlnHnaH0sa3OWXkkgs+LPQGp51zPjK31HzrxY0!knY1q5glK1IMUflCmHPgp5ycewElXasTgVhavY+Cpjtg6J+8OAQva3o61Hu4lV3EdvmOLEB+hTHP!/A==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 6671
 by: olcott - Wed, 3 Nov 2021 21:18 UTC

On 11/3/2021 4:03 PM, André G. Isaak wrote:
> On 2021-11-03 14:02, olcott wrote:
>> On 11/3/2021 2:02 PM, André G. Isaak wrote:
>>> On 2021-11-03 12:23, olcott wrote:
>>>> On 11/3/2021 12:44 PM, André G. Isaak wrote:
>>>>> On 2021-11-03 11:19, olcott wrote:
>>>>>> On 11/3/2021 12:09 PM, André G. Isaak wrote:
>>>>>>> On 2021-11-03 10:14, olcott wrote:
>>>>>>>> On 11/3/2021 11:00 AM, André G. Isaak wrote:
>>>>>>>>> On 2021-11-03 09:47, olcott wrote:
>>>>>>>>>
>>>>>>>>>> THE IS THE MOST RECENT UPDATE TO THE CRITERION MEASURE
>>>>>>>>>> A halt decider only need answer whether or not the correct
>>>>>>>>>> pure simulation of its input would ever reach a final state of
>>>>>>>>>> this input by a simulating halt decider.
>>>>>>>>>
>>>>>>>>> The halting problem already defines what the criterion used by
>>>>>>>>> a halt decider must be. You don't get to update it if that's
>>>>>>>>> the problem you want to work on.
>>>>>>>>>
>>>>>>>>> André
>>>>>>>>>
>>>>>>>>
>>>>>>>> No one here seems capable of understanding is that when a halt
>>>>>>>> decider does correctly decide the halt status of its input then
>>>>>>>> its input has had its halt status correctly decided.
>>>>>>>
>>>>>>> Right. And since yours doesn't correctly decide the halt status
>>>>>>> of its input then its input has not had its halt status correctly
>>>>>>> decided.
>>>>>>>
>>>>>>
>>>>>> The only criteria for correctly deciding the halt status of the
>>>>>> actual input is whether or not the correct pure simulation of this
>>>>>> input would ever reach a final state.
>>>>>>
>>>>>> Every other criteria changes the subject to an entirely different
>>>>>> comutation.
>>>>>
>>>>>
>>>>> Both 'halting problem' and 'halt decider' were defined before you
>>>>> were born by people who actually UNDERSTOOD the topic.
>>>>>
>>>>> The definitions of these things are precise, unambiguous, and
>>>>> clearly indicate the actual criterion which a halt decider must use
>>>>> in making its decision. That criterion makes no reference to pure
>>>>> simulations. It refers only to whether the computation represented
>>>>> by the input string halts.
>>>>>
>>>>
>>>> It is impossible for any halt decider to be incorrect when the
>>>> correct pure simulation of its input never halts and it reports not
>>>> halting.
>>>
>>> Not if it contradicts the actual correct answer as determined by the
>>> criterion which defines the halting problem since that criterion
>>> alone determines which answer is correct.
>> It is impossible for any halt decider to be incorrect when the correct
>> pure simulation of its input never halts and it reports not halting.
>
> But your halt decider doesn't implement a 'pure simulation' under any
> reasonable definition of the term.

_P()
[00000c36](01) 55 push ebp
[00000c37](02) 8bec mov ebp,esp
[00000c39](03) 8b4508 mov eax,[ebp+08] // 2nd Param
[00000c3c](01) 50 push eax
[00000c3d](03) 8b4d08 mov ecx,[ebp+08] // 1st Param
[00000c40](01) 51 push ecx
[00000c41](05) e820fdffff call 00000966 // call H
[00000c46](03) 83c408 add esp,+08
[00000c49](02) 85c0 test eax,eax
[00000c4b](02) 7402 jz 00000c4f
[00000c4d](02) ebfe jmp 00000c4d
[00000c4f](01) 5d pop ebp
[00000c50](01) c3 ret
Size in bytes:(0027) [00000c50]

Begin Local Halt Decider Simulation at Machine Address:c36

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00000c36][002117ca][002117ce] 55 push ebp
[00000c37][002117ca][002117ce] 8bec mov ebp,esp
[00000c39][002117ca][002117ce] 8b4508 mov eax,[ebp+08]
[00000c3c][002117c6][00000c36] 50 push eax // push P
[00000c3d][002117c6][00000c36] 8b4d08 mov ecx,[ebp+08]
[00000c40][002117c2][00000c36] 51 push ecx // push P
[00000c41][002117be][00000c46] e820fdffff call 00000966 // call H(P,P)

We can perfectly know that H(P,P) does precisely simulate the first
seven instructions of P when it simulates the first seven instructions
of P.

We can also know that when it perfectly repeats this sequence again that
it has acted as a pure simulator for the execution of these two sequences.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ complete proof that I am correct? ]

<AcydnQ1q1uRmjh78nZ2dnUU7-fnNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/computers/article-flat.php?id=7546&group=comp.ai.philosophy#7546

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 03 Nov 2021 17:58:03 -0500
Date: Wed, 3 Nov 2021 17:58:01 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.2.1
Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [
complete proof that I am correct? ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <ucydnX2Rbvl4_-L8nZ2dnUU7-bHNnZ2d@giganews.com>
<874k8wrvxv.fsf@bsb.me.uk> <mamdnfcmEbsDYuL8nZ2dnUU7-ffNnZ2d@giganews.com>
<87ee7zqz75.fsf@bsb.me.uk> <heKdndbYnPukHx38nZ2dnUU7-WnNnZ2d@giganews.com>
<87lf26pueb.fsf@bsb.me.uk> <xsudnaztFImi1Bz8nZ2dnUU7-fHNnZ2d@giganews.com>
<874k8upp9k.fsf@bsb.me.uk> <t_mdnSlILtJIwhz8nZ2dnUU7-KnNnZ2d@giganews.com>
<87y266o7p4.fsf@bsb.me.uk> <dZOdneAiX5IV-xz8nZ2dnUU7-RfNnZ2d@giganews.com>
<87mtmmo4gh.fsf@bsb.me.uk> <slrsns$kn8$2@dont-email.me>
<87zgqmgc6y.fsf@bsb.me.uk> <x8-dnRaPVNKeMh_8nZ2dnUU7-UnNnZ2d@giganews.com>
<slubnd$s6d$1@dont-email.me> <ILGdnVv-3NrIKB_8nZ2dnUU7-YfNnZ2d@giganews.com>
<slufo0$t8l$1@dont-email.me> <5Z6dnZzsq4ApWR_8nZ2dnUU7-eGdnZ2d@giganews.com>
<sluhq6$dsk$1@dont-email.me> <7I6dndlGh-80Th_8nZ2dnUU7-YvNnZ2d@giganews.com>
<slumbk$iqu$1@dont-email.me> <C86dnR0hvLVZdx_8nZ2dnUU78TXNnZ2d@giganews.com>
<slutej$a29$1@dont-email.me> <VY2dnSq8-uQhYR_8nZ2dnUU7-cHNnZ2d@giganews.com>
<slv1dc$5pb$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <slv1dc$5pb$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AcydnQ1q1uRmjh78nZ2dnUU7-fnNnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-a7mZHDgkraLwdo/UpI5/dqJtUjEdQIgkXy9eDSG8fO/ZXExeG8fPyBRgfnSLswdHUFYarv1b2b+UE9A!RYHfMgJgFeRcftgCmpM0eu8VvqhWbcsJcXVeGSY8GzJP2rpbzV5WZyQcVvS11bu6HzNW/osy4RHw!YQ==
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 4902
 by: olcott - Wed, 3 Nov 2021 22:58 UTC

On 11/3/2021 5:10 PM, André G. Isaak wrote:
> On 2021-11-03 15:18, olcott wrote:
>> On 11/3/2021 4:03 PM, André G. Isaak wrote:
>
>>> But your halt decider doesn't implement a 'pure simulation' under any
>>> reasonable definition of the term.
>>
>> _P()
>> [00000c36](01)  55          push ebp
>> [00000c37](02)  8bec        mov ebp,esp
>> [00000c39](03)  8b4508      mov eax,[ebp+08] // 2nd Param
>> [00000c3c](01)  50          push eax
>> [00000c3d](03)  8b4d08      mov ecx,[ebp+08] // 1st Param
>> [00000c40](01)  51          push ecx
>> [00000c41](05)  e820fdffff  call 00000966    // call H
>> [00000c46](03)  83c408      add esp,+08
>> [00000c49](02)  85c0        test eax,eax
>> [00000c4b](02)  7402        jz 00000c4f
>> [00000c4d](02)  ebfe        jmp 00000c4d
>> [00000c4f](01)  5d          pop ebp
>> [00000c50](01)  c3          ret
>> Size in bytes:(0027) [00000c50]
>>
>> Begin Local Halt Decider Simulation at Machine Address:c36
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00000c36][002117ca][002117ce] 55          push ebp
>> [00000c37][002117ca][002117ce] 8bec        mov ebp,esp
>> [00000c39][002117ca][002117ce] 8b4508      mov eax,[ebp+08]
>> [00000c3c][002117c6][00000c36] 50          push eax       // push P
>> [00000c3d][002117c6][00000c36] 8b4d08      mov ecx,[ebp+08]
>> [00000c40][002117c2][00000c36] 51          push ecx       // push P
>> [00000c41][002117be][00000c46] e820fdffff  call 00000966  // call H(P,P)
>>
>> We can perfectly know that H(P,P) does precisely simulate the first
>> seven instructions of P when it simulates the first seven instructions
>> of P.
>>
>> We can also know that when it perfectly repeats this sequence again
>> that it has acted as a pure simulator for the execution of these two
>> sequences.
>
> And so what? Somethings either a pure simulator or it isn't.

That it is a pure simulator to this point conclusively proves that
it is a pure simulator up to this point and conclusively proves that
a pure simulation would never halt.

It is impossible for any halt decider to be incorrect when the correct
pure simulation of its input never halts and it reports not halting.

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor