Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

panic: kernel trap (ignored)


devel / comp.theory / Re: Airtight proof that H(P,P)==0 is correct

SubjectAuthor
* Airtight proof that H(P,P)==0 is correctolcott
+* Airtight proof that H(P,P)==0 is correctMalcolm McLean
|`* Airtight proof that H(P,P)==0 is correctolcott
| `* Airtight proof that H(P,P)==0 is correctBen Bacarisse
|  `* Airtight proof that H(P,P)==0 is correctolcott
|   `* Airtight proof that H(P,P)==0 is correctAndré G. Isaak
|    `* Airtight proof that H(P,P)==0 is correctolcott
|     `* Airtight proof that H(P,P)==0 is correctAndré G. Isaak
|      `* Airtight proof that H(P,P)==0 is correctolcott
|       `* Airtight proof that H(P,P)==0 is correctBen Bacarisse
|        `* Airtight proof that H(P,P)==0 is correctolcott
|         `- Airtight proof that H(P,P)==0 is correctRichard Damon
+* Airtight proof that H(P,P)==0 is correctAndré G. Isaak
|`* Airtight proof that H(P,P)==0 is correctolcott
| +* Airtight proof that H(P,P)==0 is correctChris M. Thomasson
| |`* Airtight proof that H(P,P)==0 is correctolcott
| | `* Airtight proof that H(P,P)==0 is correctChris M. Thomasson
| |  `* Airtight proof that H(P,P)==0 is correctolcott
| |   `* Airtight proof that H(P,P)==0 is correctChris M. Thomasson
| |    `- Airtight proof that H(P,P)==0 is correctolcott
| `* Airtight proof that H(P,P)==0 is correctAndré G. Isaak
|  +- Airtight proof that H(P,P)==0 is correctJeff Barnett
|  `* _Airtight_proof_that_H(P,P)==0_is_correct_[_deficiency_of_André's_reasoning_]olcott
|   `* _Airtight_proof_that_H(P,P)==0_is_correct_André G. Isaak
|    `* _Airtight_proof_that_H(P,P)==0_is_correct_[_deficiency_of_André's_reasoning_]olcott
|     `- _Airtight_proof_that_H(P,P)==0_is_correct_Richard Damon
`- Airtight proof that H(P,P)==0 is correctRichard Damon

Pages:12
Airtight proof that H(P,P)==0 is correct

<WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20426&group=comp.theory#20426

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.logic
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
 by: olcott - Mon, 30 Aug 2021 14:35 UTC

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

Re: Airtight proof that H(P,P)==0 is correct

<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20427&group=comp.theory#20427

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a37:aa01:: with SMTP id t1mr23535514qke.369.1630339305061;
Mon, 30 Aug 2021 09:01:45 -0700 (PDT)
X-Received: by 2002:a25:2aca:: with SMTP id q193mr24808262ybq.494.1630339304805;
Mon, 30 Aug 2021 09:01:44 -0700 (PDT)
Path: i2pn2.org!i2pn.org!paganini.bofh.team!usenet.pasdenom.info!usenet-fr.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Mon, 30 Aug 2021 09:01:44 -0700 (PDT)
In-Reply-To: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:89a3:5cfc:d847:a0e8;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:89a3:5cfc:d847:a0e8
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
Subject: Re: Airtight proof that H(P,P)==0 is correct
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Mon, 30 Aug 2021 16:01:45 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Malcolm McLean - Mon, 30 Aug 2021 16:01 UTC

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?

Re: Airtight proof that H(P,P)==0 is correct

<sgj0q3$bpr$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20429&group=comp.theory#20429

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 10:25:37 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 57
Message-ID: <sgj0q3$bpr$1@dont-email.me>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 30 Aug 2021 16:25:39 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="6bc49f3cd0bb7c6891f5646fb17ba8e3";
logging-data="12091"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+yzWYb9hk8g6Rr9lFMhjWj"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:NWbFju78zE6XpGlL1Kc6o0wVxbY=
In-Reply-To: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 30 Aug 2021 16:25 UTC

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.

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

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

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.

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.

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.

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é

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

Re: Airtight proof that H(P,P)==0 is correct

<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20431&group=comp.theory#20431

 copy link   Newsgroups: comp.theory
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:01:58 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 12:01:57 -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: <9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 7bit
Message-ID: <mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com>
Lines: 38
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-1dC29md+w2TolPHUKx0mbX1jbs1Ol/RbYcNos5PbAzp4ScUN1FRuwdYyDYCkCZ/rx2v1g1ZGNmG8ylj!D6jq07B1wfklwIDnbtjesalaCiQrnJBJi20xSk+bTQY5vz6ndD9nBYJ0C7jFRMAuuybFb0LchQbZ!7XA=
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: 2926
 by: olcott - Mon, 30 Aug 2021 17:01 UTC

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

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

int main() { P(P); } is an entirely different computation than int
main() { H(P,P); } that can have opposite behavior without
contradiction. int main() { P(P); } is off-topic for this thread and
will not be discussed.

Pages 3-4 of my paper have been updated to elaborate the same
Airtight proof that 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

Re: Airtight proof that H(P,P)==0 is correct

<tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20432&group=comp.theory#20432

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.logic
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
 by: olcott - Mon, 30 Aug 2021 17:15 UTC

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

Re: Airtight proof that H(P,P)==0 is correct

<sgjcvc$131g$4@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20434&group=comp.theory#20434

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!ux6ld97kLXxG8kVFFLnoWg.user.46.165.242.75.POSTED!not-for-mail
From: chris.m....@gmail.com (Chris M. Thomasson)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 12:53:14 -0700
Organization: Aioe.org NNTP Server
Message-ID: <sgjcvc$131g$4@gioia.aioe.org>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="35888"; posting-host="ux6ld97kLXxG8kVFFLnoWg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Chris M. Thomasson - Mon, 30 Aug 2021 19:53 UTC

On 8/30/2021 10:15 AM, 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.
[...]

Can you _solve_ the halting problem in general, or not?

Re: Airtight proof that H(P,P)==0 is correct

<7aGdnQii5Nrip7D8nZ2dnUU78LudnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20435&group=comp.theory#20435

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!border2.nntp.ams1.giganews.com!nntp.giganews.com!buffer2.nntp.ams1.giganews.com!buffer1.nntp.ams1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 30 Aug 2021 15:07:27 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjcvc$131g$4@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 15:07:26 -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: <sgjcvc$131g$4@gioia.aioe.org>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <7aGdnQii5Nrip7D8nZ2dnUU78LudnZ2d@giganews.com>
Lines: 26
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-UsquW9UZHedyh6maODKngVIUgL2TCE1xtJFSd+rqtJslFUVY3cAOLl+WSuDrSZzaQQVRgv/cWgRtO1d!wHJikPAN4xvqwPh22i+zkXsKsNb5J5P08EmV75+ZiU+/cI9kSTF1LZldKt95Kn4UuTRUg8+N5e5t!nB4=
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: 2234
X-Received-Bytes: 2356
 by: olcott - Mon, 30 Aug 2021 20:07 UTC

On 8/30/2021 2:53 PM, Chris M. Thomasson wrote:
> On 8/30/2021 10:15 AM, 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.
> [...]
>
> Can you _solve_ the halting problem in general, or not?
>

That question is ridiculous.
I never intended to write a computer program that has the mind of God.

--
Copyright 2021 Pete Olcott

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

Re: Airtight proof that H(P,P)==0 is correct

<sgjg38$uhn$1@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20436&group=comp.theory#20436

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!ux6ld97kLXxG8kVFFLnoWg.user.46.165.242.75.POSTED!not-for-mail
From: chris.m....@gmail.com (Chris M. Thomasson)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 13:46:29 -0700
Organization: Aioe.org NNTP Server
Message-ID: <sgjg38$uhn$1@gioia.aioe.org>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjcvc$131g$4@gioia.aioe.org>
<7aGdnQii5Nrip7D8nZ2dnUU78LudnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="31287"; posting-host="ux6ld97kLXxG8kVFFLnoWg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Chris M. Thomasson - Mon, 30 Aug 2021 20:46 UTC

On 8/30/2021 1:07 PM, olcott wrote:
> On 8/30/2021 2:53 PM, Chris M. Thomasson wrote:
>> On 8/30/2021 10:15 AM, 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.
>> [...]
>>
>> Can you _solve_ the halting problem in general, or not?
>>
>
> That question is ridiculous.
> I never intended to write a computer program that has the mind of God.
>

So, how do you decide if an unknown program halts or not?

Re: Airtight proof that H(P,P)==0 is correct

<Bo-dnSzCWZo71bD8nZ2dnUU7-L-dnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20437&group=comp.theory#20437

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 30 Aug 2021 16:07:50 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com> <sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com> <sgjcvc$131g$4@gioia.aioe.org> <7aGdnQii5Nrip7D8nZ2dnUU78LudnZ2d@giganews.com> <sgjg38$uhn$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 16:07:49 -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: <sgjg38$uhn$1@gioia.aioe.org>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <Bo-dnSzCWZo71bD8nZ2dnUU7-L-dnZ2d@giganews.com>
Lines: 39
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-vd3WvZG9Yj+uSw0e7VaNvWmlsf+rndniE2jMUQdzT0RxO6dC2jYaUt5KlpX6eHF8TwcRVoabXjTlgDs!Egq0mJ1JILpMw9NTTI1ugsoMW8GRJ6GoSibliYiRn/CdJ7tYmrQ/ZP64nHBYE2NBUAdelPsgPTv+!3GM=
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: 2780
 by: olcott - Mon, 30 Aug 2021 21:07 UTC

On 8/30/2021 3:46 PM, Chris M. Thomasson wrote:
> On 8/30/2021 1:07 PM, olcott wrote:
>> On 8/30/2021 2:53 PM, Chris M. Thomasson wrote:
>>> On 8/30/2021 10:15 AM, 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.
>>> [...]
>>>
>>> Can you _solve_ the halting problem in general, or not?
>>>
>>
>> That question is ridiculous.
>> I never intended to write a computer program that has the mind of God.
>>
>
> So, how do you decide if an unknown program halts or not?

The behavior pattern of the execution trace is examined.

The simplest concrete example is explained on pages 3-4 of my updated
paper:

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: Airtight proof that H(P,P)==0 is correct

<sgjk1k$mhi$1@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20438&group=comp.theory#20438

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!ux6ld97kLXxG8kVFFLnoWg.user.46.165.242.75.POSTED!not-for-mail
From: chris.m....@gmail.com (Chris M. Thomasson)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 14:53:54 -0700
Organization: Aioe.org NNTP Server
Message-ID: <sgjk1k$mhi$1@gioia.aioe.org>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjcvc$131g$4@gioia.aioe.org>
<7aGdnQii5Nrip7D8nZ2dnUU78LudnZ2d@giganews.com> <sgjg38$uhn$1@gioia.aioe.org>
<Bo-dnSzCWZo71bD8nZ2dnUU7-L-dnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Info: gioia.aioe.org; logging-data="23090"; posting-host="ux6ld97kLXxG8kVFFLnoWg.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
X-Notice: Filtered by postfilter v. 0.9.2
Content-Language: en-US
 by: Chris M. Thomasson - Mon, 30 Aug 2021 21:53 UTC

On 8/30/2021 2:07 PM, olcott wrote:
> On 8/30/2021 3:46 PM, Chris M. Thomasson wrote:
>> On 8/30/2021 1:07 PM, olcott wrote:
>>> On 8/30/2021 2:53 PM, Chris M. Thomasson wrote:
>>>> On 8/30/2021 10:15 AM, 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.
>>>> [...]
>>>>
>>>> Can you _solve_ the halting problem in general, or not?
>>>>
>>>
>>> That question is ridiculous.
>>> I never intended to write a computer program that has the mind of God.
>>>
>>
>> So, how do you decide if an unknown program halts or not?
>
> The behavior pattern of the execution trace is examined.
>
> The simplest concrete example is explained on pages 3-4 of my updated
> paper:
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>

So, you solved the halting problem, or not?

Re: Airtight proof that H(P,P)==0 is correct

<sgjkd8$jks$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20439&group=comp.theory#20439

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 16:00:06 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 171
Message-ID: <sgjkd8$jks$1@dont-email.me>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 30 Aug 2021 22:00:09 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="5cf0a664913c29b948826b4026e132f1";
logging-data="20124"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1/nh2xR4n6hQPcP4uY9MfyE"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:LBASCyImwSaKsNd0ziIwqM17U/o=
In-Reply-To: <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 30 Aug 2021 22:00 UTC

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.

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

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

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

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

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

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.

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

André

> (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:
>

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

Re: Airtight proof that H(P,P)==0 is correct

<A_idnRbXEOnix7D8nZ2dnUU7-c-dnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20440&group=comp.theory#20440

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 30 Aug 2021 17:23:59 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjcvc$131g$4@gioia.aioe.org>
<7aGdnQii5Nrip7D8nZ2dnUU78LudnZ2d@giganews.com> <sgjg38$uhn$1@gioia.aioe.org>
<Bo-dnSzCWZo71bD8nZ2dnUU7-L-dnZ2d@giganews.com> <sgjk1k$mhi$1@gioia.aioe.org>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 17:23:58 -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: <sgjk1k$mhi$1@gioia.aioe.org>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <A_idnRbXEOnix7D8nZ2dnUU7-c-dnZ2d@giganews.com>
Lines: 51
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jhffzMwgu3C+NpT/SIf/qUESBLo2wCl0IS35iYw1rrGIt+lpNvtNIT3ePqa+aRggOyq5/WuBmbUT9Ww!zxz7XlxBREKy4PGbk3NCshKcJsRQhC9m8+s4QCjYENmfxKBpYPQ7NBwXza1Jizsb83K3puEg/0Jm!NeY=
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: 3309
X-Received-Bytes: 3488
 by: olcott - Mon, 30 Aug 2021 22:23 UTC

On 8/30/2021 4:53 PM, Chris M. Thomasson wrote:
> On 8/30/2021 2:07 PM, olcott wrote:
>> On 8/30/2021 3:46 PM, Chris M. Thomasson wrote:
>>> On 8/30/2021 1:07 PM, olcott wrote:
>>>> On 8/30/2021 2:53 PM, Chris M. Thomasson wrote:
>>>>> On 8/30/2021 10:15 AM, 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.
>>>>> [...]
>>>>>
>>>>> Can you _solve_ the halting problem in general, or not?
>>>>>
>>>>
>>>> That question is ridiculous.
>>>> I never intended to write a computer program that has the mind of God.
>>>>
>>>
>>> So, how do you decide if an unknown program halts or not?
>>
>> The behavior pattern of the execution trace is examined.
>>
>> The simplest concrete example is explained on pages 3-4 of my updated
>> paper:
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>>
>
> So, you solved the halting problem, or not?

My only goal was to refute the conventional halting problem proofs.

Actually solving the halting problem requires a computer program with
the mind of God. It must be literally ALL KNOWING about computer programs.

--
Copyright 2021 Pete Olcott

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

Re: Airtight proof that H(P,P)==0 is correct

<sgjq4e$jhg$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20441&group=comp.theory#20441

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 17:37:45 -0600
Organization: A noiseless patient Spider
Lines: 20
Message-ID: <sgjq4e$jhg$1@dont-email.me>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjkd8$jks$1@dont-email.me>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: quoted-printable
Injection-Date: Mon, 30 Aug 2021 23:37:50 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="b3ffdf216e79544573c95bb53d9ea67b";
logging-data="20016"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18kaUmgMLfgZ1InN5cFwUc5x9NWcj2jYhs="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:78.0) Gecko/20100101
Thunderbird/78.13.0
Cancel-Lock: sha1:Z5nxgLAGRjGK9/u2hwl8OEK+KvQ=
In-Reply-To: <sgjkd8$jks$1@dont-email.me>
Content-Language: en-US
 by: Jeff Barnett - Mon, 30 Aug 2021 23:37 UTC

On 8/30/2021 4:00 PM, André G. Isaak wrote:
> On 2021-08-30 11:15, olcott wrote:
<SNIP>> If you think bring this up is a 'dodge', then it means you
clearly don't
> understand what the halting problem is. At all.

You are clearly correct that he/she doesn't understand what the halting
problem is. However, I'm not sure if he knows what a "dodge" is either.

Here in the good old US of A, a dodge is a Chrysler product; an auto
that proudly leaks oil, will not hold a tune up adjustment, and is an
all around piece of poop. It's incomprehensible that so many people
would buy them. So saying that PO brings something up as a dodge is
virtually a truism. In fact PO could have been VP in charge of auto
maintenance at Chrysler and that would explain the worst 50 years long
maintenance failure in history. Its mind does bare a strong familiarity
to a car wreck.
--
Jeff Barnett

Re: Airtight proof that H(P,P)==0 is correct

<I0eXI.4001$6U3.3983@fx43.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20442&group=comp.theory#20442

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!news-out.netnews.com!news.alt.net!fdc3.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.iad.POSTED!not-for-mail
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 185
Message-ID: <I0eXI.4001$6U3.3983@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 30 Aug 2021 19:41:26 -0400
X-Received-Bytes: 9114
 by: Richard Damon - Mon, 30 Aug 2021 23:41 UTC

On 8/30/21 10:35 AM, 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.

MEANING OF WORDS:

A (anything) Halt Decider is, BY DEFINITION, a Computation that when
given a representation of another Computation, indicates if the
computation whose representation it was given will Halt with an answer
in Finite Time, or if it will never halt in unbounded time.

Halting is DEFINED as reaching a final halting state in a finite number
of steps.

Correct, by definition, means the answer matches the required answer.

A Computation is, by definition, a predefined algorith of fixed steps
that can be applied to its input to come up with an answer, or possible
never return an answer (The last clause is omitted by some, and they
just define that an algorithm that never returns an answer as not being
a computation).

By this definition, if P(I) halts then the only correct answer for
H(P,I) is halting.

Since it is established that for an H that answers non-halting for
H(<H^>,<H^>) the for the H^ built from that H, that H^(<H^>) does halt,
BY DEFINITION, that H was wrong.

Your statement is WRONG, because it ignores the possibility that the
predefined algorithm of H might INCORRECTLY abort its simulation, and
thus it INCORRECTLY decide what the computation it is provided does not
halt, and the due to that incorrect decision, the machine that used it
does halt.

Since the Simulation Halt Decider has a PREDEFINED algorithm, it can't
argue about what an input that is based on it would do if it was based
on a DIFFERENT decider than it. THAT is an ERROR.

A predefined algorithm can NOT be just 'give the right answer', as that
is NOT an algorithm.

The correct statement of your statement would be:

A Simulating Halt Decider correctly decides that any input that never
halts unless THIS COPY of the Simulationg Halt Decider CORRECTLY aborts
its simulation of this input (and any other copies copies continue to
act as originally defined) is a non-halting Computation.

>
> (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:
>

Worng. SINCE the H within P will abort its simulation of P(P), and
return the non-halting answer and P will halt, if the simulation of this
machine was allowed to continue, H is WRONG to abort its simulation of P(P).

This is verified by looking at the behavior of just running P(P).

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

UNSOUND, this presumes that H will never abort its simulation as part of
its Halt Deciding. Since H will, this is an UNSOUND logic process.

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

Re: Airtight proof that H(P,P)==0 is correct [ deficiency of André's reasoning ]

<Z6SdnTctB4LzH7D8nZ2dnUU7-YHNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20444&group=comp.theory#20444

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.math.symbolic
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
 by: olcott - Tue, 31 Aug 2021 01:14 UTC

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()
{
Click here to read the complete article

Re: Airtight proof that H(P,P)==0 is correct [ deficiency of André's reasoning ]

<sgk24j$qek$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20445&group=comp.theory#20445

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re:_Airtight_proof_that_H(P,P)==0_is_correct_
[_deficiency_of_André's_reasoning_]
Date: Mon, 30 Aug 2021 19:54:24 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 314
Message-ID: <sgk24j$qek$1@dont-email.me>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjkd8$jks$1@dont-email.me> <Z6SdnTctB4LzH7D8nZ2dnUU7-YHNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 31 Aug 2021 01:54:28 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="5cf0a664913c29b948826b4026e132f1";
logging-data="27092"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18skJVYmOmYbR1hnXiuS9yX"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:tSrUQVwufrz+OHgaKhxvHz+RpjM=
In-Reply-To: <Z6SdnTctB4LzH7D8nZ2dnUU7-YHNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 31 Aug 2021 01:54 UTC

On 2021-08-30 19:14, olcott wrote:
> 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.

Your grasp of epistemology is clearly wanting. We know that cats are
animals based on observations of cats.

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

No. They are not. You seem to use the phrase 'self-evidently true' as
shorthand, for 'this sounds plausible to me but I'm not sure how to
prove it'.

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

They actively reject it because you give an invalid argument to justify
it, as has been repeatedly pointed out.

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

It's premises? What the hell are you talking about. Functions take
*arguments*, not 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

Under the dominion? That's a very peculiar phrasing. P(P) isn't being
computed at all when we run H(P, P). The halting status of P(P) is being
evaluated. And P(P) halts.

Every TM description + input string description identifies a *unique*
computation.

When you pass H the arguments (P, P) it can't just change to some
distinct computation from P(P) because H *by definition* is being asked
about P(P). If it's answer doesn't correspond to the behaviour of P(P)
(== int main() { P(P); }) then it is WRONG.

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


Click here to read the complete article
Re: Airtight proof that H(P,P)==0 is correct [ deficiency of André's reasoning ]

<pvednbFdrPVRDLD8nZ2dnUU7-UfNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20448&group=comp.theory#20448

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.swapon.de!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc3.netnews.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 30 Aug 2021 21:19:56 -0500
Subject: Re:_Airtight_proof_that_H(P,P)==0_is_correct_[_deficiency_of_André's_reasoning_]
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com> <sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com> <sgjkd8$jks$1@dont-email.me> <Z6SdnTctB4LzH7D8nZ2dnUU7-YHNnZ2d@giganews.com> <sgk24j$qek$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 21:19:54 -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: <sgk24j$qek$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <pvednbFdrPVRDLD8nZ2dnUU7-UfNnZ2d@giganews.com>
Lines: 306
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-5IvmRMGzZ45gfAkyNRhKz1PymNbbrs/Wi0Ql1DFXzKOMctW54IPCxI/V1Y/7FQrJVAvJD0LHYmVGjE2!KOhDWSxYoxcykh44C0YVykpAdEG3duTbxRtoh2BkTRc1ETlLfVEi61dm+Zv8+amEUfpzA+Dpn5Pu!Yyw=
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: 14678
 by: olcott - Tue, 31 Aug 2021 02:19 UTC

On 8/30/2021 8:54 PM, André G. Isaak wrote:
> On 2021-08-30 19:14, olcott wrote:
>> 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.
>
> Your grasp of epistemology is clearly wanting. We know that cats are
> animals based on observations of cats.
>
>>>> 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.
>
> No. They are not. You seem to use the phrase 'self-evidently true' as
> shorthand, for 'this sounds plausible to me but I'm not sure how to
> prove it'.
>
>>>>> 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.
>
> They actively reject it because you give an invalid argument to justify
> it, as has been repeatedly pointed out.
>
>>>> 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.
>
> It's premises? What the hell are you talking about. Functions take
> *arguments*, not 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
>
> Under the dominion? That's a very peculiar phrasing. P(P) isn't being
> computed at all when we run H(P, P). The halting status of P(P) is being
> evaluated. And P(P) halts.
>
> Every TM description + input string description identifies a *unique*
> computation.
>
> When you pass H the arguments (P, P) it can't just change to some
> distinct computation from P(P) because H *by definition* is being asked
> about P(P). If it's answer doesn't correspond to the behaviour of P(P)
> (== int main() { P(P); }) then it is WRONG.
>
>>> 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.
>
> Of course the halting status of H(Infinite_Loop) and of Infinite_Loop()
> are different. But Infinite_Loop doesn't become a halting computation
> when passed as an argument to H. That H(Infinite_Loop) halts doesn't
> suddenly make Infinite Loop() become a halting computation.
> Infinite_Loop() isn't being computed at all when we run H(Infinite_Loop).
>
> Similarly P(P) and H(P, P) are distinct computation with distinct
> halting behaviours. When we run H(P, P), P(P) isn't being computed, only
> H(P, P) is being computed. but you want to claim that the *input* to
> H(P, P) represents some distinct computation from P(P) which is
> completely incoherent. That somehow the *input* to H(P, P) is
> non-halting despite the fact that the actual computation P(P) is halting.
>
> If your H's answer doesn't match the behaviour of the *actual*
> computation P(P), then it is not answering the question it is supposed
> to be answering.
>
>>
>>>>> 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.
>
> OF COURSE IT MATTERS,
Like I said your reasoning is very deficient:
When X is necessitated by Y and Z and Y and Z are true then we know X is
true and nothing in the universe can possibly change this.


Click here to read the complete article
Re: Airtight proof that H(P,P)==0 is correct [ deficiency of André's reasoning ]

<MqgXI.8673$z%4.1273@fx37.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20449&group=comp.theory#20449

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx37.iad.POSTED!not-for-mail
Subject: Re:_Airtight_proof_that_H(P,P)==0_is_correct_
[_deficiency_of_André's_reasoning_]
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<sgj0q3$bpr$1@dont-email.me> <tI2dnVYlEYahj7D8nZ2dnUU7-UPNnZ2d@giganews.com>
<sgjkd8$jks$1@dont-email.me> <Z6SdnTctB4LzH7D8nZ2dnUU7-YHNnZ2d@giganews.com>
<sgk24j$qek$1@dont-email.me> <pvednbFdrPVRDLD8nZ2dnUU7-UfNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0)
Gecko/20100101 Thunderbird/78.13.0
MIME-Version: 1.0
In-Reply-To: <pvednbFdrPVRDLD8nZ2dnUU7-UfNnZ2d@giganews.com>
Content-Type: text/plain; charset=utf-8
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Lines: 307
Message-ID: <MqgXI.8673$z%4.1273@fx37.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 30 Aug 2021 22:25:47 -0400
X-Received-Bytes: 14803
 by: Richard Damon - Tue, 31 Aug 2021 02:25 UTC

On 8/30/21 10:19 PM, olcott wrote:
> On 8/30/2021 8:54 PM, André G. Isaak wrote:
>> On 2021-08-30 19:14, olcott wrote:
>>> 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.
>>
>> Your grasp of epistemology is clearly wanting. We know that cats are
>> animals based on observations of cats.
>>
>>>>> 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.
>>
>> No. They are not. You seem to use the phrase 'self-evidently true' as
>> shorthand, for 'this sounds plausible to me but I'm not sure how to
>> prove it'.
>>
>>>>>> 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.
>>
>> They actively reject it because you give an invalid argument to
>> justify it, as has been repeatedly pointed out.
>>
>>>>> 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.
>>
>> It's premises? What the hell are you talking about. Functions take
>> *arguments*, not 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
>>
>> Under the dominion? That's a very peculiar phrasing. P(P) isn't being
>> computed at all when we run H(P, P). The halting status of P(P) is
>> being evaluated. And P(P) halts.
>>
>> Every TM description + input string description identifies a *unique*
>> computation.
>>
>> When you pass H the arguments (P, P) it can't just change to some
>> distinct computation from P(P) because H *by definition* is being
>> asked about P(P). If it's answer doesn't correspond to the behaviour
>> of P(P) (== int main() { P(P); }) then it is WRONG.
>>
>>>> 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.
>>
>> Of course the halting status of H(Infinite_Loop) and of
>> Infinite_Loop() are different. But Infinite_Loop doesn't become a
>> halting computation when passed as an argument to H. That
>> H(Infinite_Loop) halts doesn't suddenly make Infinite Loop() become a
>> halting computation. Infinite_Loop() isn't being computed at all when
>> we run H(Infinite_Loop).
>>
>> Similarly P(P) and H(P, P) are distinct computation with distinct
>> halting behaviours. When we run H(P, P), P(P) isn't being computed,
>> only H(P, P) is being computed. but you want to claim that the *input*
>> to H(P, P) represents some distinct computation from P(P) which is
>> completely incoherent. That somehow the *input* to H(P, P) is
>> non-halting despite the fact that the actual computation P(P) is halting.
>>
>> If your H's answer doesn't match the behaviour of the *actual*
>> computation P(P), then it is not answering the question it is supposed
>> to be answering.
>>
>>>
>>>>>> 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.
>>
>> OF COURSE IT MATTERS,
> Like I said your reasoning is very deficient:
> When X is necessitated by Y and Z and Y and Z are true then we know X is
> true and nothing in the universe can possibly change this.
>
> Like I said your reasoning is very deficient:
> When X is necessitated by Y and Z and Y and Z are true then we know X is
> true and nothing in the universe can possibly change this.
>
> Like I said your reasoning is very deficient:
> When X is necessitated by Y and Z and Y and Z are true then we know X is
> true and nothing in the universe can possibly change this.
>
> Like I said your reasoning is very deficient:
> When X is necessitated by Y and Z and Y and Z are true then we know X is
> true and nothing in the universe can possibly change this.
>


Click here to read the complete article
Re: Airtight proof that H(P,P)==0 is correct

<871r6a5otx.fsf@bsb.me.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20450&group=comp.theory#20450

 copy link   Newsgroups: comp.theory
Followup: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Followup-To: comp.theory
Date: Tue, 31 Aug 2021 03:29:30 +0100
Organization: A noiseless patient Spider
Lines: 32
Message-ID: <871r6a5otx.fsf@bsb.me.uk>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain
Injection-Info: reader02.eternal-september.org; posting-host="68d107aaa1e2a2dcd8559f0becbaf137";
logging-data="30680"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+e7nFpp2meIKkOuctxSSsdw2tkPM18/r0="
Cancel-Lock: sha1:hh064o9NPnONSUZSmku7ulxQTPE=
sha1:ydLHaMJD4iWHYp4zidOmXYURAQI=
X-BSB-Auth: 1.4e379755ff8ddeab5b87.20210831032930BST.871r6a5otx.fsf@bsb.me.uk
 by: Ben Bacarisse - Tue, 31 Aug 2021 02:29 UTC

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.

> 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".

--
Ben.

Re: Airtight proof that H(P,P)==0 is correct

<hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20453&group=comp.theory#20453

 copy link   Newsgroups: comp.theory comp.ai.philosophy comp.software-eng sci.logic
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
 by: olcott - Tue, 31 Aug 2021 02:45 UTC

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

Re: Airtight proof that H(P,P)==0 is correct

<sgk5pg$9o0$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20455&group=comp.theory#20455

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 20:56:47 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 66
Message-ID: <sgk5pg$9o0$1@dont-email.me>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com> <871r6a5otx.fsf@bsb.me.uk>
<hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 31 Aug 2021 02:56:49 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="5cf0a664913c29b948826b4026e132f1";
logging-data="9984"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX18mXs7eT/EaMJUgHA3fF0sf"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:o97KuLKkMc/YWizRa0zL2I7mZME=
In-Reply-To: <hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 31 Aug 2021 02:56 UTC

On 2021-08-30 20:45, olcott wrote:
> 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.

And what on earth are "its two premises"?

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

Again, what are "its two premises"?

> (b) The truth of these two premises

Again, what are "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".
>>
>
>

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

Re: Airtight proof that H(P,P)==0 is correct

<4K6dnaCCasmfArD8nZ2dnUU7-b3NnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20458&group=comp.theory#20458

 copy link   Newsgroups: comp.theory
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 22:16:18 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com> <871r6a5otx.fsf@bsb.me.uk>
<hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com> <sgk5pg$9o0$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 22:16:15 -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: <sgk5pg$9o0$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <4K6dnaCCasmfArD8nZ2dnUU7-b3NnZ2d@giganews.com>
Lines: 82
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-wdFkMfKN4+eZ9ZJz337QBeog9D4+i516nUQQ4ClmqdJGj1I6nzMZwFXN48YFOJh93bVveCQJgsXiZVd!lSET6Yel//BmSOmTAByBM/rVn0UWqPHcVkf0M78sYkca2ScZ8lK+Kak7GOQKmCdN/IgpK4Z8i6Cj!QBM=
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: 4259
 by: olcott - Tue, 31 Aug 2021 03:16 UTC

On 8/30/2021 9:56 PM, André G. Isaak wrote:
> On 2021-08-30 20:45, olcott wrote:
>> 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.
>
> And what on earth are "its two premises"?
>
>> Everything besides:
>> (a) The logical necessity relationship between {H(P,P)==0 is correct}
>> and its two premises.
>
> Again, what are "its two premises"?
>
>> (b) The truth of these two premises
>
> Again, what are "these two premises"?
>

See that you haven't been paying any attention all along. They are in
the original thread. They have been rewritten on page 4 of my paper:

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

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

Re: Airtight proof that H(P,P)==0 is correct

<sgk74g$fe9$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20459&group=comp.theory#20459

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Mon, 30 Aug 2021 21:19:44 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 72
Message-ID: <sgk74g$fe9$1@dont-email.me>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com> <871r6a5otx.fsf@bsb.me.uk>
<hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com> <sgk5pg$9o0$1@dont-email.me>
<4K6dnaCCasmfArD8nZ2dnUU7-b3NnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Tue, 31 Aug 2021 03:19:45 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="5cf0a664913c29b948826b4026e132f1";
logging-data="15817"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19/wxV9pJoeGCBArdh1zOJl"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0)
Gecko/20100101 Thunderbird/68.12.1
Cancel-Lock: sha1:VfT50ApRp5r/8/3pS/Rp0cdg0Cw=
In-Reply-To: <4K6dnaCCasmfArD8nZ2dnUU7-b3NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Tue, 31 Aug 2021 03:19 UTC

On 2021-08-30 21:16, olcott wrote:
> On 8/30/2021 9:56 PM, André G. Isaak wrote:
>> On 2021-08-30 20:45, olcott wrote:
>>> 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.
>>
>> And what on earth are "its two premises"?
>>
>>> Everything besides:
>>> (a) The logical necessity relationship between {H(P,P)==0 is correct}
>>> and its two premises.
>>
>> Again, what are "its two premises"?
>>
>>> (b) The truth of these two premises
>>
>> Again, what are "these two premises"?
>>
>
> See that you haven't been paying any attention all along. They are in
> the original thread. They have been rewritten on page 4 of my paper:
>
> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

Nowhere on page 4 are two premises listed.

André

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

Re: Airtight proof that H(P,P)==0 is correct

<ovednVh4qaDvPbD8nZ2dnUU7-cWdnZ2d@giganews.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20461&group=comp.theory#20461

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Mon, 30 Aug 2021 22:22:26 -0500
Subject: Re: Airtight proof that H(P,P)==0 is correct
Newsgroups: comp.theory
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com> <9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com> <mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com> <871r6a5otx.fsf@bsb.me.uk> <hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com> <sgk5pg$9o0$1@dont-email.me> <4K6dnaCCasmfArD8nZ2dnUU7-b3NnZ2d@giganews.com> <sgk74g$fe9$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
Date: Mon, 30 Aug 2021 22:22:25 -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: <sgk74g$fe9$1@dont-email.me>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: en-US
Content-Transfer-Encoding: 8bit
Message-ID: <ovednVh4qaDvPbD8nZ2dnUU7-cWdnZ2d@giganews.com>
Lines: 80
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rMmBw50i2VyfU3Rng6X/mkek/+9rzXZVATXBwQbpox974vRRNDhLefmxNyLbacZ4vDeCWCBU7q4KW/c!mBOPPQSmkcZ2+X7vyL/AKnqDUybz0+LTO85ammWHZl8m1TkQ3L5OUAIaLBkjaVAy7kjwcho+gls/!xoY=
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: 4354
 by: olcott - Tue, 31 Aug 2021 03:22 UTC

On 8/30/2021 10:19 PM, André G. Isaak wrote:
> On 2021-08-30 21:16, olcott wrote:
>> On 8/30/2021 9:56 PM, André G. Isaak wrote:
>>> On 2021-08-30 20:45, olcott wrote:
>>>> 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.
>>>
>>> And what on earth are "its two premises"?
>>>
>>>> Everything besides:
>>>> (a) The logical necessity relationship between {H(P,P)==0 is
>>>> correct} and its two premises.
>>>
>>> Again, what are "its two premises"?
>>>
>>>> (b) The truth of these two premises
>>>
>>> Again, what are "these two premises"?
>>>
>>
>> See that you haven't been paying any attention all along. They are in
>> the original thread. They have been rewritten on page 4 of my paper:
>>
>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>
>
> Nowhere on page 4 are two premises listed.
>
> André
>
>

Follow the reasoning and then reverse engineer what the premises are.

--
Copyright 2021 Pete Olcott

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

Re: Airtight proof that H(P,P)==0 is correct

<87k0k23psj.fsf@bsb.me.uk>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=20468&group=comp.theory#20468

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: ben.use...@bsb.me.uk (Ben Bacarisse)
Newsgroups: comp.theory
Subject: Re: Airtight proof that H(P,P)==0 is correct
Date: Tue, 31 Aug 2021 10:51:40 +0100
Organization: A noiseless patient Spider
Lines: 23
Message-ID: <87k0k23psj.fsf@bsb.me.uk>
References: <WaSdnZLVNdE-cbH8nZ2dnUU7-RvNnZ2d@giganews.com>
<9f9f7436-d66d-4136-8c33-3a96f148fff1n@googlegroups.com>
<mtWdndX2vNmbkrD8nZ2dnUU7-dfNnZ2d@giganews.com>
<871r6a5otx.fsf@bsb.me.uk>
<hOqdnQ2eNY9-CrD8nZ2dnUU7-TPNnZ2d@giganews.com>
<sgk5pg$9o0$1@dont-email.me>
<4K6dnaCCasmfArD8nZ2dnUU7-b3NnZ2d@giganews.com>
<sgk74g$fe9$1@dont-email.me>
<ovednVh4qaDvPbD8nZ2dnUU7-cWdnZ2d@giganews.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=iso-8859-1
Content-Transfer-Encoding: 8bit
Injection-Info: reader02.eternal-september.org; posting-host="68d107aaa1e2a2dcd8559f0becbaf137";
logging-data="3666"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+3+d4xrosYeimw8x4QijYkoboimi84Dhg="
Cancel-Lock: sha1:PHpoug7nyJotdjbVBxIUpKOMgi0=
sha1:0HG/4xebvfxCuukehP9LJTv07Ms=
X-BSB-Auth: 1.a7bd53244359298a5b72.20210831105140BST.87k0k23psj.fsf@bsb.me.uk
 by: Ben Bacarisse - Tue, 31 Aug 2021 09:51 UTC

olcott <NoOne@NoWhere.com> writes:

> On 8/30/2021 10:19 PM, André G. Isaak wrote:
>> On 2021-08-30 21:16, olcott wrote:
>>> On 8/30/2021 9:56 PM, André G. Isaak wrote:

>>>> Again, what are "these two premises"?
>>>
>>> See that you haven't been paying any attention all along. They are
>>> in the original thread. They have been rewritten on page 4 of my
>>> paper:
>>>
>>> https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation
>>
>> Nowhere on page 4 are two premises listed.
>> André
>
> Follow the reasoning and then reverse engineer what the premises are.

Classic! Have we reached "peak crank" yet? Let's hope so...

--
Ben.

Pages:12
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor