Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

The system was down for backups from 5am to 10am last Saturday.


computers / comp.ai.philosophy / Re: Concise refutation of halting problem proofs

SubjectAuthor
* Concise refutation of halting problem proofsolcott
+- Re: Concise refutation of halting problem proofs [ ta-da ? ]olcott
+* Re: Concise refutation of halting problem proofs [ focus on one pointolcott
|`- Re: Concise refutation of halting problem proofs [ focus on one pointolcott
+* Re: Concise refutation of halting problem proofsolcott
|`- Re: Concise refutation of halting problem proofsolcott
`- Re: Concise refutation of halting problem proofs [ Richard seems toolcott

1
Concise refutation of halting problem proofs

<vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic alt.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 04 Nov 2021 10:47:54 -0500
Date: Thu, 4 Nov 2021 10:47:53 -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,alt.philosophy
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: Concise refutation of halting problem proofs
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
Lines: 90
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-So6t1+3EJ5nw8MT0chGGT3CLHwCakhFv2ZpxQX2F7c2joxlILSiMHBlnaO6YwS2pu2ZjydL6XvtyeP7!LGJ4GJ3+ilX+iJBuxVu+L9+jRHV0FS+1HeBzp+A+ZCvYJbxqPipLDsmqaXnBEgROeTZDwrRS/G6k!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: 4951
 by: olcott - Thu, 4 Nov 2021 15:47 UTC

This tiny little proof totally proves that the counter-examples of all
of the conventional halting problem proofs do not prove that the halting
problem cannot be solved.

This is the simplest example of the classic halting problem input that
"proves" that the halting problem cannot be solved.
https://en.wikipedia.org/wiki/Halting_problem

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

This is the assembly language of the above function after it has been
translated by the Microsoft C compiler.

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

Verified facts:
(1) The above 14 simulated lines are a correct pure simulation of the
input to H(P,P) for every possible encoding of simulating halt decider H.

(2) The above 14 simulated lines conclusively prove that the pure
simulation of the input to H(P,P) would never reach its final state of
c50 for every possible encoding of simulating halt decider H.

(1) and (2) conclusively prove that H(P,P) meets this criteria:

2021-11-03 Halt Deciding Criteria
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.

Strachey, C 1965.  An impossible program The Computer Journal, Volume 7,
Issue 4, January 1965, Page 313, https://doi.org/10.1093/comjnl/7.4.313

Linz, Peter 1990. An Introduction to Formal Languages and Automata.
Lexington/Toronto: D. C. Heath and Company. (318-320)

Halting problem undecidability and infinitely nested simulation
May 2021 PL Olcott

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

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs [ ta-da ? ]

<kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Thu, 04 Nov 2021 17:32:30 -0500
Date: Thu, 4 Nov 2021 17:32:29 -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: Concise refutation of halting problem proofs [ ta-da ? ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<jLSdnS1o5tcA0xn8nZ2dnUU7-XXNnZ2d@giganews.com> <sm1j1f$i2g$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm1j1f$i2g$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <kIydnbUqUOXjwhn8nZ2dnUU7-TPNnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Gnek4aSFLnWchM2JzJ6OlJ3tDWcu8cJy1qD3LJ6nPSqTp9s/iKfDt21W0Y5CeuiOdSMrGn80sbuNzv8!/q24mI5Hcwb8yqKwbPGIhcD9U3bhiv5Myff0Zw8c0VoTrtO6Vi6xDgmUBte/1E5iqS6k1iIukIKl!Bg==
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: 3342
 by: olcott - Thu, 4 Nov 2021 22:32 UTC

On 11/4/2021 4:23 PM, André G. Isaak wrote:
> On 2021-11-04 15:20, olcott wrote:
>> On 11/4/2021 3:09 PM, Malcolm McLean wrote:
>>> On Thursday, 4 November 2021 at 17:41:31 UTC, André G. Isaak wrote:
>>>>
>>>>> (1) The above 14 simulated lines are a correct pure simulation of the
>>>>> input to H(P,P) for every possible encoding of simulating halt
>>>>> decider H.
>>>> What exactly does 'every possible encoding of simulating halt
>>>> decider H'
>>>> even mean?
>>>>
>>> You need to understand the PO is working with x86 code, not Turing
>>> machines.
>>> So P does not contain an embedded near copy of H, as in Linz's scheme,
>>> but a call to H.
>>> Now at first sight, that doesn't matter. But it allows for a mental
>>> separation
>>> between "the input" (the simple little driver which calls H and
>>> inverts behaviour
>>> when it gets the result)  and H itself (the halt decider).
>>> If we replace the call to H by a call to another simulating halt
>>> decider, have
>>> we changed anything now?
>>>
>>
>> I think that you have this correctly.
>>
>> My current proof applies to every possible encoding of H thus
>> eliminating any need to see the encoding of any specific H.
>
> Again, I ask, what do you mean by an 'encoding of H'?

The C source code. H can be written an infinite number of different ways
and each one of these ways would derive the exact same pure simulation
of its input.

Since my new proof doesn't care about whether or not H decides its input
correctly we don't need to examine the details of how H makes its halt
status decision.

My new proof merely shows that a pure simulation of the input to H(P,P)
never reaches the final state of P, therefore not halting would be a
correct halt status decision.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs [ focus on one point ]

<Ac2dnUhoceTCBBj8nZ2dnUU7-VvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 05 Nov 2021 15:51:43 -0500
Date: Fri, 5 Nov 2021 15:51:41 -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: Concise refutation of halting problem proofs [ focus on one point
]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me> <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
<sm1tmi$nr3$1@dont-email.me> <i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>
<sm1v00$vcp$1@dont-email.me> <ApidneInKNK7Exn8nZ2dnUU7-X_NnZ2d@giganews.com>
<sm3vuu$5ti$1@dont-email.me> <PP2dnesKUe8nGxj8nZ2dnUU78enNnZ2d@giganews.com>
<sm44m4$6s3$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm44m4$6s3$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Ac2dnUhoceTCBBj8nZ2dnUU7-VvNnZ2d@giganews.com>
Lines: 114
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-fQzHbxwSZAqQn0Q/nwECMdO21LWgO3Q0OTO6OqVLdfqVcBmfHCRPdziLE4UZ3oxPuJ4ReY/sfVZg+lB!ipJfy4IggiJRVotfNd7e/5cgXX+lCfQEgbkqVmLmKyq4j6hWJb3Q4vERL2HY/mCx3TaVRfq0/G2I!xg==
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: 6473
 by: olcott - Fri, 5 Nov 2021 20:51 UTC

On 11/5/2021 3:37 PM, André G. Isaak wrote:
> On 2021-11-05 13:32, olcott wrote:
>> On 11/5/2021 2:16 PM, André G. Isaak wrote:
>>> On 2021-11-04 19:51, olcott wrote:
>>>
>>>> We have to stay focused on the one single point that I perfectly and
>>>> totally proved that H did act as a pure simulator of the 14 steps of
>>>> P before we can move on to any other point.
>>>
>>> As far as I can tell you are more interested in *avoiding* critical
>>> points. The crucial points are:
>>>
>>> (1) P(P) halts when run as an independent computation.
>>> (2) Your H(P, P) claims that P(P) does *not* halt.
>>>
>>
>> What you are saying is that if the correct pure simulation of the
>> input to H(P,P) never halts it still halts anyway. AKA a black cat is
>> sometimes not a cat at all.
>
> I'm not talking about what happens inside your simulation. I'm talking
> about the *actual* computation P(P) which you yourself have acknowledged
> halts.
>

Ah so you fundamentally disagree with the concept of a UTM.

> That's the computation H(P, P) is supposed to be answering about.
>
> Go back and reread the definition of Halt Decider. A halt decider takes
> a description of a computation, but the answer it gives describes the
> *actual* computation described, not the 'behaviour of the input" (which
> is meaningless gibberish) or what goes on inside some simulating halt
> decider.
>
> P(P) halts. Ergo a halt decider must decide that it halts.

P(P) halts and the pure simulation of the input to H1(P,P) halts
and the pure simulation of the input to H(P,P) never halts conclusively
proving that it is not computationally equivalent to the above two.

>
>> It is a verified fact that the correct pure simulation of the input to
>> H(P,P) never halts therefore nothing in the universe can possibly
>> contradict this.
>
> It is *not* a verified fact. It is simply an assertion on your part.

That the 14 lines shown below conclusively prove that H does perform a
pure simulation of its input in H(P,P) is no more a mere assertion than
the assertion that the decimal integer 5 is numerically greater than the
decimal integer 3 AND YOU KNOW IT !!!

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

> The
> fact that P(P) halts and your simulation allegedly does not demonstrates
> that your simulation is not a pure, faithful simulation.
>
> Note that a trace merely shows *what* some program did. It does not
> provide evidence for the correctness of that program. So you're never
> going to convince anyone that your H is giving the correct answer simply
> by providing traces. Its a waste of electrons.
>
> The way to show that a program gives the correct answer is to compare
> the answer it gives to the ACTUAL answer as defined by the problem which
> the program is supposed to be solving.
>
> André
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs [ focus on one point ]

<C8OdnSug19D3MBj8nZ2dnUU7-anNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 05 Nov 2021 17:17:14 -0500
Date: Fri, 5 Nov 2021 17:17: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: Concise refutation of halting problem proofs [ focus on one point
]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk> <_Z6dnWOFjPmewBn8nZ2dnUU7-cPNnZ2d@giganews.com>
<sm1ms4$be5$2@dont-email.me> <raqdndTQQdfD5Bn8nZ2dnUU7-X-dnZ2d@giganews.com>
<sm1tmi$nr3$1@dont-email.me> <i46dnX8h96FH5hn8nZ2dnUU78InNnZ2d@giganews.com>
<sm1v00$vcp$1@dont-email.me> <ApidneInKNK7Exn8nZ2dnUU7-X_NnZ2d@giganews.com>
<sm3vuu$5ti$1@dont-email.me> <PP2dnesKUe8nGxj8nZ2dnUU78enNnZ2d@giganews.com>
<sm44m4$6s3$1@dont-email.me> <Ac2dnUhoceTCBBj8nZ2dnUU7-VvNnZ2d@giganews.com>
<sm46u0$mlf$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm46u0$mlf$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <C8OdnSug19D3MBj8nZ2dnUU7-anNnZ2d@giganews.com>
Lines: 129
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ojqD3DGOBafhBsEAvluO9Eu2o0zL26EpzlEalDN3oGQQdyWiNvQt2GYPDHtS6NH7Mcdcgn93EzU7IJF!G+Nc5WjxJCB9uz1sthe53T3XmzgaCDFhGNc4hM6fF5iF5in1WUD+xjwsaCD3NVZs4kT8L6YlqTTt!jQ==
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: 7065
 by: olcott - Fri, 5 Nov 2021 22:17 UTC

On 11/5/2021 4:15 PM, André G. Isaak wrote:
> On 2021-11-05 14:51, olcott wrote:
>> On 11/5/2021 3:37 PM, André G. Isaak wrote:
>>> On 2021-11-05 13:32, olcott wrote:
>>>> On 11/5/2021 2:16 PM, André G. Isaak wrote:
>>>>> On 2021-11-04 19:51, olcott wrote:
>>>>>
>>>>>> We have to stay focused on the one single point that I perfectly
>>>>>> and totally proved that H did act as a pure simulator of the 14
>>>>>> steps of P before we can move on to any other point.
>>>>>
>>>>> As far as I can tell you are more interested in *avoiding* critical
>>>>> points. The crucial points are:
>>>>>
>>>>> (1) P(P) halts when run as an independent computation.
>>>>> (2) Your H(P, P) claims that P(P) does *not* halt.
>>>>>
>>>>
>>>> What you are saying is that if the correct pure simulation of the
>>>> input to H(P,P) never halts it still halts anyway. AKA a black cat
>>>> is sometimes not a cat at all.
>>>
>>> I'm not talking about what happens inside your simulation. I'm
>>> talking about the *actual* computation P(P) which you yourself have
>>> acknowledged halts.
>>>
>>
>> Ah so you fundamentally disagree with the concept of a UTM.
>
> You don't *have* a UTM. You have a C program.
>
> And even if you were working with actual Turing Machines, you wouldn't
> have a UTM, you'd have a 'simulating halt decider'.
>
>>> That's the computation H(P, P) is supposed to be answering about.
>>>
>>> Go back and reread the definition of Halt Decider. A halt decider
>>> takes a description of a computation, but the answer it gives
>>> describes the *actual* computation described, not the 'behaviour of
>>> the input" (which is meaningless gibberish) or what goes on inside
>>> some simulating halt decider.
>>>
>>> P(P) halts. Ergo a halt decider must decide that it halts.
>>
>> P(P) halts and the pure simulation of the input to H1(P,P) halts
>
> Which takes us back to the question which you keep ignoring. You claimed
> that "an infinite number of different simulating halt deciders must have
> exactly the same behavior while they are doing a pure simulation of
> their input. "
>

Yes in the same way that an infinite number of int Add(int, X, int Y)
must derive the same sum of X + Y.

> So why do H and H1 have *different* behaviours? They can't both be pure
> simulations and have different behaviours.
>

You can simply ignore that the pathological relationship between an
input and its halt decider has no effect what-so-ever on the halt
status decision none-the-less it has been conclusively proven beyond
all possible doubt that this pathological relationship DOES FREAKING
CHANGE THE RESULT.

>> and the pure simulation of the input to H(P,P) never halts
>> conclusively proving that it is not computationally equivalent to the
>> above two.
>
> What is not computationally equivalent to what?
>

H1(P,P) != H(P,P) and their execution trace conclusively proves
that they are both correct.

The one thing that has most infuriated me my whole life is
that people stick with their false opinions directly against
the verified facts.

The opinion that climate change is not caused by humans will
make humans extinct.

https://www.researchgate.net/publication/336568434_Severe_anthropogenic_climate_change_proven_entirely_with_verifiable_facts

The opinion that the 2020 election had massive voter fraud will likely
cause Fascism to end Democracy by killing everyone that gets in their way.

The opinion that H does not correctly perform a pure simulation of
the first 14 steps of P will prevent me from getting enough credibility
to fix these other two things.

> Any halt decider which takes a description of P(P) as its input is
> answering about P(P). Ergo the behaviour of P(P) is all that matters in
> determining whether a given halting decision is correct.
>
> If your 'pure simulation' is not "computationally equivalent" to this
> then you are not answering about the right computation (and your
> simulator isn't a pure simulator).
>
>>>
>>>> It is a verified fact that the correct pure simulation of the input
>>>> to H(P,P) never halts therefore nothing in the universe can possibly
>>>> contradict this.
>>>
>>> It is *not* a verified fact. It is simply an assertion on your part.
>>
>> That the 14 lines shown below conclusively prove that H does perform a
>> pure simulation of its input in H(P,P) is no more a mere assertion
>> than the assertion that the decimal integer 5 is numerically greater
>> than the decimal integer 3 AND YOU KNOW IT !!!
>
> As I said before, traces DO NOT PROVE ANYTHING. Have you ever actually
> looked at a proof of correctness for a computer program? They don't
> involve traces. Traces are used for debugging, not for proofs. And on
> the rare occasions when people actually do look at traces they do so in
> a debugging environment where one can inspect the contents of variables
> and memory locations. A printout of a trace is WORTHLESS.
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs

<jJmdnTqYAuXL7hv8nZ2dnUU7-YvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 06 Nov 2021 07:21:42 -0500
Date: Sat, 6 Nov 2021 07:21: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: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk>
<c4c9e810-25d0-4a51-8fe7-8396d076ae77n@googlegroups.com>
<87wnlmc1xt.fsf@bsb.me.uk> <wO6dnRKBUP3WrBj8nZ2dnUU7-I_NnZ2d@giganews.com>
<87fssab1ts.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87fssab1ts.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jJmdnTqYAuXL7hv8nZ2dnUU7-YvNnZ2d@giganews.com>
Lines: 53
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-yCL7flmkl+sF6RP6TadR8PG/6WlsJwSXA3YVKXZ9D+oGS401hZOQ2zap4oMH2gZNObdA5PYd7SM7UYH!eS7njC0PeNoL3fY2fQXGZYJQ8ipFKXqR8+uGM04OB+BclUZydbsGK30gnaBTsectW62jSdDl5AAN!JQ==
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: 3583
 by: olcott - Sat, 6 Nov 2021 12:21 UTC

On 11/5/2021 6:49 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> As soon as we verify that the correct pure simulation of the input to
>> H(P,0) never reaches the last address of P at c50 we know that the
>> input to H(P,P) never halts thus the correctly halt status of
>> H(P,P)==0;
>
> But P(P) halts, so H(P,P) == 0 is the wrong result.

When the correct pure simulation of the actual input to the halt decider
never halts then the halt decider is necessarily correct when it reports
that its input never halts.

Disagreeing with a logical tautology is a break from reality.

A correct pure simulation is not verified on the basis of any mere
assumptions. As long as the first seven x86 instructions of the source
code of P are executed in order and the seventh instruction causes this
cycle to repeat then we know that H(P,P) performed a correct pure
simulation of its input for the entire 14 steps of this simulation.

Saying the the pure simulation is not correct on any other basis is a
break from reality.

If both P(P) halts and the input to H(P,P) never halts are established
facts (and they are) then it must be the case that P(P) and H(P,P) are
not computationally equivalent to each other.

> An H this is wrong
> about this key case is not interesting, unlike your H from Dec 2018:
>
> "Everyone has claimed that H on input pair (Ĥ, Ĥ) meeting the Linz specs
> does not exist. I now have a fully encoded pair of Turing Machines H / Ĥ
> proving them wrong."[1]
>
> Three years of progressively walking back that claim and you are left
> with some C function H that is wrong about H(Ĥ, Ĥ). No one thinks such
> an H does not exist. It's trivially obvious that an H that does /not/
> meet Linz's spec (for the (Ĥ, Ĥ) case) exists. They are ten-a-penny.
>
> [1] Message-ID: <JbydneYGrrpProjBnZ2dnUU7-X3NnZ2d@giganews.com>
>

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs

<Y8KdnVycj7L4Fxv8nZ2dnUU7-RvNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic comp.ai.philosophy sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 06 Nov 2021 09:00:05 -0500
Date: Sat, 6 Nov 2021 09:00: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: Concise refutation of halting problem proofs
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,comp.ai.philosophy,sci.math
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<sm1608$kn8$1@dont-email.me>
<84cb1553-5b12-433e-8577-9a260772ebc7n@googlegroups.com>
<87k0hnd3nv.fsf@bsb.me.uk>
<c4c9e810-25d0-4a51-8fe7-8396d076ae77n@googlegroups.com>
<87wnlmc1xt.fsf@bsb.me.uk> <wO6dnRKBUP3WrBj8nZ2dnUU7-I_NnZ2d@giganews.com>
<87fssab1ts.fsf@bsb.me.uk> <jJmdnTqYAuXL7hv8nZ2dnUU7-YvNnZ2d@giganews.com>
<292bb972-3e14-48a9-923e-128a629710a3n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <292bb972-3e14-48a9-923e-128a629710a3n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <Y8KdnVycj7L4Fxv8nZ2dnUU7-RvNnZ2d@giganews.com>
Lines: 41
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-TuNWH61lGHRgSyu28veKEYc2+dQKa8wpmD+8O5vcm16zdya3xqukLJXmoBBSt0cCdtpUke4oy1sKu9W!hoqYWiMOZ8qcq/DBOWOfH/qe4YmpuKkVQdjhdBYLZSHpFip+sZfVX7alTsut+k7XJb0NjPGES/+b!Pw==
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: 3350
 by: olcott - Sat, 6 Nov 2021 14:00 UTC

On 11/6/2021 7:53 AM, Malcolm McLean wrote:
> On Saturday, 6 November 2021 at 12:21:49 UTC, olcott wrote:
>> On 11/5/2021 6:49 PM, Ben Bacarisse wrote:
>>> olcott <No...@NoWhere.com> writes:
>>>
>>>> As soon as we verify that the correct pure simulation of the input to
>>>> H(P,0) never reaches the last address of P at c50 we know that the
>>>> input to H(P,P) never halts thus the correctly halt status of
>>>> H(P,P)==0;
>>>
>>> But P(P) halts, so H(P,P) == 0 is the wrong result.
>> When the correct pure simulation of the actual input to the halt decider
>> never halts then the halt decider is necessarily correct when it reports
>> that its input never halts.
>>
>> Disagreeing with a logical tautology is a break from reality.
>> A correct pure simulation is not verified on the basis of any mere
>> assumptions. As long as the first seven x86 instructions of the source
>> code of P are executed in order and the seventh instruction causes this
>> cycle to repeat then we know that H(P,P) performed a correct pure
>> simulation of its input for the entire 14 steps of this simulation.
>>
> The first seven steps are indeed simulated. But the next seven steps are
> simulated by the copy of H that is called from P.

Conclusively proving that the correct pure simulation of the input to
H(P,P) never halts, thus H(P,P)==0 is correct.

> So they shouldn't appear
> in the instruction trace. If we simulate "push ebp" we don't actually push
> ebp to the stack. We create a virtual stack in memory and push a value to
> it.

--
Copyright 2021 Pete Olcott

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

Re: Concise refutation of halting problem proofs [ Richard seems to understand this ]

<kdKdnUCH7rZ5ZBv8nZ2dnUU7-ffNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory sci.logic sci.math comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 06 Nov 2021 16:55:48 -0500
Date: Sat, 6 Nov 2021 16:55:47 -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: Concise refutation of halting problem proofs [ Richard seems to
understand this ]
Content-Language: en-US
Newsgroups: comp.theory,sci.logic,sci.math,comp.ai.philosophy
References: <vLedncx8wLA3nRn8nZ2dnUU7-XfNnZ2d@giganews.com>
<87y263deg7.fsf@bsb.me.uk> <dNidnZrKUJ4byhn8nZ2dnUU7-LfNnZ2d@giganews.com>
<87ee7vcsgd.fsf@bsb.me.uk> <K_idnXAS1_D-Ehn8nZ2dnUU7-dPNnZ2d@giganews.com>
<87r1buc11b.fsf@bsb.me.uk> <vuednS2MQ8HOqRj8nZ2dnUU7-V3NnZ2d@giganews.com>
<87a6iib1aa.fsf@bsb.me.uk> <RKqdnTBXWdnm6Bv8nZ2dnUU7-InNnZ2d@giganews.com>
<87fss989u8.fsf@bsb.me.uk> <CYmdnZME1ptTXRv8nZ2dnUU7-aHNnZ2d@giganews.com>
<sm6pk0$14q$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <sm6pk0$14q$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <kdKdnUCH7rZ5ZBv8nZ2dnUU7-ffNnZ2d@giganews.com>
Lines: 70
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-owIsRLTNgrZO+DlhGpSp2GeM7QdVG0Woj1SQqy8ahKLNpRLom5djAOu9Z8ZILKj5v5PrC50m9EWjuGE!MAIS/64SHrc6aSGjg2f0CIcp9mGVJuzWdigNwTAhc2hN1s6bpUQcdt1WH/0CUvAquBpvU/RdCppW!TA==
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: 4632
 by: olcott - Sat, 6 Nov 2021 21:55 UTC

On 11/6/2021 3:46 PM, André G. Isaak wrote:
> On 2021-11-06 11:52, olcott wrote:
>
>> The brand new exception to the rule that the pure simulation of a
>> machine description on its input and the direct execution of this
>> machine on its input ARE COMPUTATIONALLY EQUIVALENT is the case where
>> the decider and its machine description input have a pathological
>> relationship to each other.
>
> And you justify this incoherent claim how exactly?
>

The actual pure simulation of the first 14 steps of the x86 machine
language input to H(P,P) conclusively proves beyond all possible doubt
that H(P,P)==0 is correct even of H never returns.

You won't be able to understand what I am saying until after you
comprehend this fact. Ben is hopelessly lost because he is utterly
clueless about the x86 language, perhaps you too are utterly clueless
about the x86 language.

> If the pure simulation isn't computationally equivalent to the direct
> execution, in what possible sense is it a 'pure simulation'?
>

I have told you this too many times.

When each instruction of the x86 source code is simulated in the exact
same sequence that it is specified in the source code we know that this
aspect of the simulation is perfectly correct.

We also know that when H is a pure simulator of its input that the
seventh line of the correct pure simulation execution trace shown below
would result in another identical sequence.

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 don't need to see the 350 pages of the simulation of H to know that
if this H does a pure simulation of its input that the above seven lines
will be repeated in the subsequent nested simulation.

> And if your 'simulating halt decider' is simulating something which is
> not computationally equivalent to the computation described by its
> input, then in what possible sense is it actually answering a question
> about its input?
>
> P(P) halts. A halt decider must therefore claim that it halts. If it
> decides that some simulation which is not computationally equivalent to
> P(P) doesn't halt then it isn't answering about its input, which means
> it isn't a halt decider at all.
>
> André
>
>

--
Copyright 2021 Pete Olcott

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

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor