Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  nodelist  faq  login

Brain fried -- Core dumped


computers / comp.ai.philosophy / Re: Airtight proof that H(P,P)==0 is correct

SubjectAuthor
* Airtight proof that H(P,P)==0 is correctolcott
+* Re: Airtight proof that H(P,P)==0 is correctolcott
|`- Re: _Airtight_proof_that_H(P,P)==0_is_correct_[_deficiency_of_André's_reasolcott
`- Re: Airtight proof that H(P,P)==0 is correctolcott

1
Subject: Airtight proof that H(P,P)==0 is correct
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.logic
Date: Mon, 30 Aug 2021 14:35 UTC
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!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: Mon, 30 Aug 2021 09:35:15 -0500
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.logic
X-Mozilla-News-Host: news://news.giganews.com:119
From: NoO...@NoWhere.com (olcott)
Subject: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 09:35:13 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
Lines: 129
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-J8pCcvi0BjrlDEYVhU3hUrStYjmx8xrmit2dGdzfygMMc1hCFbfAEdppWXHTnH1PwkF/uD/Pxl4coad!kQi07w7vFJZ5nvau9Ox4IOVwrhg0TgCpfys/eIoTgGhT2m3vdhMaQRDtRcFuwAQGjgfa1ZBhMGx9!vYo=
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: 6426
View all headers
My point is fully proven on the basis of two other points:
(1) Verified as true entirely on the basis of the meaning of its words:
A simulating halt decider correctly decides that any input that never halts unless the simulating halt decider aborts its simulation of this input is an input that never halts.

(2) It can be verified that the input to H(P,P) never halts unless H aborts it. This is verified on the basis that the execution trace of P meets this criteria:

where H = X() and P = Y()

Infinite recursion detection criteria:
If the execution trace of function X() called by function Y() shows:
(a) Function X() is called twice in sequence from the same machine address of Y().
(b) With the same parameters to X().
(c) With no conditional branch or indexed jump instructions in Y().
(d) With no function call returns from X().
then the function call from Y() to X() is infinitely recursive.

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

Infinite recursion detection criteria:
(a) P calls H twice in sequence from the same machine address.
(b) with the same parameters (P,P) to H.
(c) With no conditional branch or indexed jump instructions in the execution trace of P.
(d) We know that there are no return instructions in H because we know that H is in pure simulation mode.

This conclusively proves that P never halts unless H aborts its simulation of P:

[00000c68][0010172a][00000000] 83c408      add esp,+08
[00000c6b][00101726][00000000] 50          push eax
[00000c6c][00101722][00000357] 6857030000  push 00000357
[00000c71][00101722][00000357] e810f7ffff  call 00000386
Input_Halts = 0
[00000c76][0010172a][00000000] 83c408      add esp,+08
[00000c79][0010172a][00000000] 33c0        xor eax,eax
[00000c7b][0010172e][00100000] 5d          pop ebp
[00000c7c][00101732][00000068] c3          ret
Number_of_User_Instructions(27)
Number of Instructions Executed(23721)

I will not tolerate changing the subject away from:
(a) How we know (1) is true.
(b) How we know (2) is true.
(c) How we know (1) and (2) entails H(P,P)==0 is correct

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: Airtight proof that H(P,P)==0 is correct
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.logic
Date: Mon, 30 Aug 2021 17:15 UTC
References: 1 2
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 30 Aug 2021 12:15:40 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.logic
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 12:15:38 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <sgj0q3$bpr$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
Lines: 107
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-hLCBXFM1XtCZaYBu5zIwQ5ShnxiHtxGNCObAy3IEFk3BRWh6EcXJ32+6EFVKfMFTnZjfHZqJLvpXwYZ!awVZI6F9wZ4BQJemTqgD9TSd6U2CV9zoSTYtsED9MbuaNXqFz+L50F90h1gosKCKRKYW/Q7HR8/U!NrQ=
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: 5792
View all headers
On 8/30/2021 11:25 AM, André G. Isaak wrote:
On 2021-08-30 08:35, olcott wrote:
My point is fully proven on the basis of two other points:
(1) Verified as true entirely on the basis of the meaning of its words:

Claiming that something is 'verified as true entirely on the basis of the meaning of its words' isn't a valid substitute for a proof.


That all cats are animals and all animals are living things is a perfectly sound deductive proof that all cats are living things.

That you fail to comprehend that proofs can be entirely based on the meaning of words is merely your error based on an incorrectly narrow minded focus.

A simulating halt decider correctly decides that any input that never halts unless the simulating halt decider aborts its simulation of this input is an input that never halts.

(2) It can be verified that the input to H(P,P) never halts unless H aborts it. This is verified on the basis that the execution trace of P meets this criteria:

where H = X() and P = Y()

Infinite recursion detection criteria:
If the execution trace of function X() called by function Y() shows:
(a) Function X() is called twice in sequence from the same machine address of Y().
(b) With the same parameters to X().
(c) With no conditional branch or indexed jump instructions in Y().
(d) With no function call returns from X().
then the function call from Y() to X() is infinitely recursive.

First off, you simply state the above criteria without actually offering any *proof* that these criteria actually work.


They above criteria have been extensively reviewed and critiqued, none-the-less for the point at hand it is quite obvious to every honest person that has a sufficient understanding of x86 assembly language that the simulation of P on input P by H never halts while H is in pure simulation mode.

And second, even if these criteria are valid, your trace *doesn't* actually meet these criteria because you deliberately omit portions of the code from your trace (i.e. everything that happens starting at address 966).


This is explained on pages 3-4 of my updated paper. That people continue to ignore sound reasoning is no actual rebuttal at all.

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

The claim that 'it can be verified that the input to H(P, P) never halts unless H aborts it.' Is not verified at all, since it can easily shown to be false by simply observing the fact that P(P) does, in fact, halt.


Yet again you twist my words. This is the straw-man error. See pages 3-4 of my paper.

You try to get around this by claiming that when you call H(P, P) the input magically changes to some *other* computation which isn't equivalent to P(P) and that this *other* computation is non-halting, but even if such a claim made sense, it means your H is answering about the *wrong* computation.


int main() { P(P); } will not be discussed on this thread.
I will no longer tolerate dishonest dodges away from the the point.

And from your recent posts in a different thread, it appears you are also claiming that it is not possible to even ask your H about the real P(P), which is the case we're really concerned about.


int main() { P(P); } will not be discussed on this thread.
I will no longer tolerate dishonest dodges away from the the point.

If your H can't even be asked about the real P(P), then it isn't even answering the question a halt decider is supposed to answer. So what's the point of your H?

André


The only thing that will be discussed on this thread is the
[Airtight proof that H(P,P)==0 is correct] on the basis that (1) and (2) are true. Everything else will be construed as a dishonest dodge.

(1) Verified as true entirely on the basis of the meaning of its words:
A simulating halt decider correctly decides that any input that never halts unless the simulating halt decider aborts its simulation of this input is an input that never halts.

(2) It can be verified that the input to H(P,P) never halts unless H aborts it. This is verified on the basis that the execution trace of P meets this criteria:

--
Copyright 2021 Pete Olcott

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


Subject: Re:_Airtight_proof_that_H(P,P)==0_is_correct_[_deficiency_of_André's_reasoning_]
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.math.symbolic
Date: Tue, 31 Aug 2021 01:14 UTC
References: 1 2 3 4
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.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: Mon, 30 Aug 2021 20:14:22 -0500
Subject: Re:_Airtight_proof_that_H(P,P)==0_is_correct_[_deficiency_of_André's_reasoning_]
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.math.symbolic
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com> <sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com> <sgjkd8$jks$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 20:14:21 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <sgjkd8$jks$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Z6SdnTctB4LzH7D8nZ2dnUU7-YHNnZ2d@giganews.com>
Lines: 274
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-NzwioPr8Ydh9/O3vUzubA7cPC6awRTDNOxPqCQpqPN2GCc7Rx9+VLN0eoQWfTcJXWT3RncU0F0OtnUt!YXYIGRi6YEDZeBIdFIyWKxUyjo8Nud2A1GsmY9V7RWSTb3xIdmSdO38UWUCQAZFKkQkQjcTCIM8O!okM=
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: 12699
View all headers
On 8/30/2021 5:00 PM, André G. Isaak wrote:
On 2021-08-30 11:15, olcott wrote:
On 8/30/2021 11:25 AM, André G. Isaak wrote:
On 2021-08-30 08:35, olcott wrote:
My point is fully proven on the basis of two other points:
(1) Verified as true entirely on the basis of the meaning of its words:

Claiming that something is 'verified as true entirely on the basis of the meaning of its words' isn't a valid substitute for a proof.


That all cats are animals and all animals are living things is a perfectly sound deductive proof that all cats are living things.

Yes, that's a valid proof. It also contains identifiable premises and a conclusion which can be linked to those premises by accepted rules of logic. It doesn't just say 'verified on the basis of the meaning of the words' which is *not* a valid proof.


We only know that a cat is an animal and that an animal is a living thing on the basis of the meaning of those words. We don't know this by any other means.

That you fail to comprehend that proofs can be entirely based on the meaning of words is merely your error based on an incorrectly narrow minded focus.

A simulating halt decider correctly decides that any input that never halts unless the simulating halt decider aborts its simulation of this input is an input that never halts.

(2) It can be verified that the input to H(P,P) never halts unless H aborts it. This is verified on the basis that the execution trace of P meets this criteria:

where H = X() and P = Y()

Infinite recursion detection criteria:
If the execution trace of function X() called by function Y() shows:
(a) Function X() is called twice in sequence from the same machine address of Y().
(b) With the same parameters to X().
(c) With no conditional branch or indexed jump instructions in Y().
(d) With no function call returns from X().
then the function call from Y() to X() is infinitely recursive.

First off, you simply state the above criteria without actually offering any *proof* that these criteria actually work.


They above criteria have been extensively reviewed and critiqued, none-the-less for the point at hand it is quite obvious to every honest person that has a sufficient understanding of x86 assembly language that the simulation of P on input P by H never halts while H is in pure simulation mode.

They have been critiqued, but they haven't been *accepted*. Again, you need to provide a proof that these criteria are valid. You can't just state them.


The criteria are self-evidently true.

And second, even if these criteria are valid, your trace *doesn't* actually meet these criteria because you deliberately omit portions of the code from your trace (i.e. everything that happens starting at address 966).


This is explained on pages 3-4 of my updated paper. That people continue to ignore sound reasoning is no actual rebuttal at all.

People don't merely ignore it. They actively reject it on the grounds that it is not valid reasoning.


The actively reject on the presumption that it seems to be invalid reasoning to them when they make sure not follow the details that prove it is valid.

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
The claim that 'it can be verified that the input to H(P, P) never halts unless H aborts it.' Is not verified at all, since it can easily shown to be false by simply observing the fact that P(P) does, in fact, halt.


Yet again you twist my words. This is the straw-man error. See pages 3-4 of my paper.

You try to get around this by claiming that when you call H(P, P) the input magically changes to some *other* computation which isn't equivalent to P(P) and that this *other* computation is non-halting, but even if such a claim made sense, it means your H is answering about the *wrong* computation.


int main() { P(P); } will not be discussed on this thread.
I will no longer tolerate dishonest dodges away from the the point.

int main() { P(P); } is *precisely* the computation which H(P, P) is supposed to be evaluating.


int main() { P(P); } will not be discussed on this thread.
int main() { P(P); } will not be discussed on this thread.
int main() { P(P); } will not be discussed on this thread.
int main() { P(P); } will not be discussed on this thread.

Refusing to discuss this is like refusing to discuss the results of 2 + 2 = 4 when trying to justify that sum(2, 2) == 5.


H(P,P)==0 is correct is a necessary consequence of its two premises.
H(P,P)==0 is correct is a necessary consequence of its two premises.
H(P,P)==0 is correct is a necessary consequence of its two premises.
H(P,P)==0 is correct is a necessary consequence of its two premises.

Anything outside of this necessary consequence is a dishonest dodge.

Failure to pay enough attention to understand that this is a necessary consequence is a dishonest dodge.

And from your recent posts in a different thread, it appears you are also claiming that it is not possible to even ask your H about the real P(P), which is the case we're really concerned about.


int main() { P(P); } will not be discussed on this thread.
I will no longer tolerate dishonest dodges away from the the point.

int main() { P(P); } is what corresponds to Linz's H_Hat(H_Hat).


More precisely:

Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ halts, and

Ĥ.q0 ⟨Ĥ1⟩ ⊢* Ĥ.qx ⟨Ĥ1⟩ ⟨Ĥ2⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ1⟩ applied to ⟨Ĥ2⟩ does not halt

Ĥ applied to ⟨Ĥ⟩ is
exactly analogous to int main() { P((u32)P); }

Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is exactly analogous to
H(P,P) called from main() { P((u32)P); }

Ĥ applied to ⟨Ĥ⟩ is a different computation than
Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ because the latter is under the dominion of a simulating halt decider

int main() { P((u32)P); } is a different computation than
H(P,P) because the latter is under the dominion of a simulating halt decider

This, according to you, is the *only* case you care about since if your H can solve it you think it would refute Linz.

If P(P) magically represents some 'different' computation when it is given as an input to H(P, P) then (putting aside the fact that this illustrates you don't understand what a computation is) it means that H(P, P) is evaluating the *wrong* computation.

And the fact that you claim P(P) represents some 'different' computation when it is given as an input to your simulating halt decider, this rather clearly shows that the simulating portion of your decider is *broken*. If it simulates P(P), it must behave as P(P) behaves, not as some 'other' computation.

You can't simply ignore the elephant in the room, which is the behaviour of main() { P(P); }.

If you think bring this up is a 'dodge', then it means you clearly don't understand what the halting problem is. At all.

A halt decider is a program which takes as its argument some other program and the input to that program (whether it be a C program, a TM, or whatever) and determines whether that program halts.

H(P, P) *needs* to determine whether the independent program P(P) (i.e main() { P(P); } halts. If it instead answers about what happens when P(P) is simulated by your H in a way that somehow changes the nature of the computation, then it is not answering the the question a halt decider is, by definition, supposed to answer.

If it simply reports on the behaviour of P(P) inside a broken simulator, why would that result be of interest to *anyone*. It's a "computation" which only exists inside some specific piece of software.


void Infinite_Loop()
{
   HERE: goto HERE;
}

int main()
{
   Output("Input_Halts = ", H0((u32)Infinite_Loop));
   Infinite_Loop();
}

The simplest way to see that a computation under the dominion of a simulating halt decider can be entirely different than direct execution is that line 1 of main halts and line 2 of main never halts.


If your H can't even be asked about the real P(P), then it isn't even answering the question a halt decider is supposed to answer. So what's the point of your H?

André


The only thing that will be discussed on this thread is the
[Airtight proof that H(P,P)==0 is correct] on the basis that (1) and (2) are true. Everything else will be construed as a dishonest dodge.

You can't dictate what other people discuss. You want to ignore the elephant in the room. You can't reasonably expect others to go along with your delusion and pretend it isn't there. It is. It needs to be discussed.


I will not tolerate dishonest dodges. I will only discuss that
H(P,P)==0 is correct is a necessary consequence of its two premises.

If H(P,P)==0 is a necessary consequence of its two premises and its two premises are true then it necessarily makes no difference what
int main() { P(P); } does. That you cannot understand this proves the deficiency of your reasoning.

If H(P,P)==0 is a necessary consequence of its two premises and its two premises are true then it necessarily makes no difference what
int main() { P(P); } does. That you cannot understand this proves the deficiency of your reasoning.

If H(P,P)==0 is a necessary consequence of its two premises and its two premises are true then it necessarily makes no difference what
int main() { P(P); } does. That you cannot understand this proves the deficiency of your reasoning.

Click here to read the complete article
Subject: Re: Airtight proof that H(P,P)==0 is correct
From: olcott
Newsgroups: comp.theory, comp.ai.philosophy, comp.software-eng, sci.logic
Date: Tue, 31 Aug 2021 02:45 UTC
References: 1 2 3 4
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.snarked.org!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, 30 Aug 2021 21:45:55 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory,comp.ai.philosophy,comp.software-eng,sci.logic
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com> <871r6a5otx.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 21:45:53 -0500
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <871r6a5otx.fsf@bsb.me.uk>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com>
Lines: 58
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-86X/eFJ300Jm0XyH6F7hUCFm3mjpS6kBYh4aFRDYz1D+gTZkYJMMlXLmYHvr+gOSdb1liAP/Qwjzx3N!7Y53j+S8UdNP0P+56gB76pU6I0numuKD47VLJ321MLZquzzs1tTEWgPt/cLvP25hf4Sa8VOZYFQP!3vQ=
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: 3567
View all headers
On 8/30/2021 9:29 PM, Ben Bacarisse wrote:
olcott <NoOne@NoWhere.com> writes:

On 8/30/2021 11:01 AM, Malcolm McLean wrote:
On Monday, 30 August 2021 at 15:35:22 UTC+1, olcott wrote:
My point is fully proven on the basis of two other points:
(1) Verified as true entirely on the basis of the meaning of its words:
A simulating halt decider correctly decides that any input that never
halts unless the simulating halt decider aborts its simulation of this
input is an input that never halts.

(2) It can be verified that the input to H(P,P) never halts unless H
aborts it. This is verified on the basis that the execution trace of P
meets this criteria:

The sounds reasonable. But there are two Hes. The halt decider, and the
copy of H in H_Hat. In your set up, these are physically the same piece
of machine code. That isn't fatal. But it does mean that we have to be
careful about what we mean by "unless H aborts it".
If we ran UTM<H_Hat><H_Hat> insread of H<H_Hat><H_Hat> what would
happen?

He won't answer that!  Not because he does not know the answer but
because he does.


Ĥ applied to ⟨Ĥ⟩ is
exactly analogous to int main() { P((u32)P); }

Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is exactly analogous to
H(P,P) called from main() { P((u32)P); }

When we know that { H(P,P)==0 is correct } is a necessary consequence of its two premises and we know that its two premises are true then {H(P,P)==0 is correct} is true by logical necessity.

Everything besides:
(a) The logical necessity relationship between {H(P,P)==0 is correct} and its two premises.

(b) The truth of these two premises

is totally 100% perfectly and utterly irrelevant to the truth of: {H(P,P)==0 is correct}.

I am not referring to H_Hat any more. H/P is much more concise and
mathematical.

Translation: "I get burned every time I talk about Turing machines so
I'll stick with some C code and a function I won't publish".



--
Copyright 2021 Pete Olcott

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


1
rocksolid light 0.7.2
clearneti2ptor