Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

[It is] best to confuse only one issue at a time. -- K&R


computers / comp.ai.philosophy / 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
Subject: Concise refutation of halting problem proofs
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, alt.philosophy
Date: Thu, 4 Nov 2021 15:47 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: 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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs [ ta-da ? ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy, sci.math
Date: Thu, 4 Nov 2021 22:32 UTC
References: 1 2 3 4 5
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs [ focus on one point ]
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy
Date: Fri, 5 Nov 2021 20:51 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!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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs [ focus on one point ]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, sci.logic, sci.math
Date: Fri, 5 Nov 2021 22:17 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: 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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy, sci.math
Date: Sat, 6 Nov 2021 12:21 UTC
References: 1 2 3 4 5 6 7 8
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs
From: olcott
Newsgroups: comp.theory, sci.logic, comp.ai.philosophy, sci.math
Date: Sat, 6 Nov 2021 14:00 UTC
References: 1 2 3 4 5 6 7 8 9 10
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
View all headers
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


Subject: Re: Concise refutation of halting problem proofs [ Richard seems to understand this ]
From: olcott
Newsgroups: comp.theory, sci.logic, sci.math, comp.ai.philosophy
Date: Sat, 6 Nov 2021 21:55 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!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
View all headers
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
rocksolid light 0.7.2
clearneti2ptor