Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

Depends on how you define "always". :-) -- Larry Wall in <199710211647.JAA17957@wall.org>


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

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 [ intuolcott
|  |+* Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuolcott
|  ||`* 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 [ impoolcott
|  ||    `* 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
Subject: H(P,P)==0 is correct for every simulating halt decider H --- V2
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Mon, 1 Nov 2021 03:45 UTC
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
View all headers
// 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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
From: olcott
Newsgroups: comp.theory, sci.logic, sci.math, comp.ai.philosophy
Date: Mon, 1 Nov 2021 14:48 UTC
References: 1 2
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy, sci.math
Date: Mon, 1 Nov 2021 14:54 UTC
References: 1 2
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Mon, 1 Nov 2021 15:15 UTC
References: 1 2 3
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 00:11 UTC
References: 1 2 3 4
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 14:20 UTC
References: 1 2 3 4 5 6
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 15:57 UTC
References: 1 2 3 4 5 6 7 8
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 20:24 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: André G. Isaak
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Organization: Christians and Atheists United Against Creeping Agnosticism
Date: Tue, 2 Nov 2021 20:38 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
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
View all headers
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.


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 20:43 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 21:41 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Tue, 2 Nov 2021 22:51 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Wed, 3 Nov 2021 01:32 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Wed, 3 Nov 2021 03:14 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy
Date: Wed, 3 Nov 2021 15:34 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
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
View all headers
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]

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)

[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

I am not going to explain the difference between H1 and H at this point because you would be overwhelmed. You first must understand that while H is a pure simulator the above seven lines of P continue to repeat.



they would be exactly the same UP TO THE POINT WHERE H MAKES ITS MISTAKE AND SAYS "INFINITE RECURSION DETECTED".  I.e. H just makes the wrong decision and terminates the simulation too early, like everyone has been saying for over a year...  :)

Mike.



--
Copyright 2021 Pete Olcott

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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy
Date: Wed, 3 Nov 2021 15:47 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy
Date: Wed, 3 Nov 2021 15:50 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy, sci.math
Date: Wed, 3 Nov 2021 16:14 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ impossibly incorrect ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Wed, 3 Nov 2021 16:20 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
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
View all headers
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]


But, again, all of this is besides the point. A halt decider is supposed to determine whether the machine described by its input halts on a given input. You acknowledge that P(P) halts. Therefore H(P, P) == 0 is incorrect. We don't need to look at a trace to know that the answer is wrong. We just need to compare the result which H(P, P) returns with the correct answer.

André



--
Copyright 2021 Pete Olcott

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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy
Date: Wed, 3 Nov 2021 16:25 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ intuition versus logic ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy
Date: Wed, 3 Nov 2021 16:26 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ][ Linz mistake ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Wed, 3 Nov 2021 16:33 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Wed, 3 Nov 2021 18:23 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ updated criterion ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic
Date: Wed, 3 Nov 2021 21:18 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
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
View all headers
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


Subject: Re: H(P,P)==0 is correct for every simulating halt decider H --- V2 [ complete proof that I am correct? ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy, sci.math
Date: Wed, 3 Nov 2021 22:58 UTC
References: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
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
View all headers
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
rocksolid light 0.7.2
clearneti2ptor