Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

You can do more with a kind word and a gun than with just a kind word. -- Al Capone


computers / comp.ai.philosophy / Halting Problem proof refutation is a tautology thus irrefutable

SubjectAuthor
* Halting Problem proof refutation is a tautology thus irrefutableolcott
+* Re: Halting Problem proof refutation is a tautology thusMr Flibble
|`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| +* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| | +- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| | `* Re: Halting Problem proof refutation is a tautology thus irrefutableMr Flibble
| |  `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |   +- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |   `* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |    `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |     `* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |      `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |       `* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        +* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |+* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        ||`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || +* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || | `* Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman Mr Flibble
| |        || |  `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   +* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | +* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | | +- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | | `* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |  `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |   `* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |    +* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |    |`- Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or iMr Flibble
| |        || |   | |    `* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |     `* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |      +- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |      `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |       +* Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or iMr Flibble
| |        || |   | |       |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |       | `- Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |       +* Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |       |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |       | +- Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |       | `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |       `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | +* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | | `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   `* Re: Halting Problem proof refutation is a tautology thus irrefutableAndré G. Isaak
| |        || |    +- Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |    `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |     +* Re: Halting Problem proof refutation is a tautology thus irrefutableAndré G. Isaak
| |        || |     |`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |     | +* Re: Halting Problem proof refutation is a tautology thus irrefutableAndré G. Isaak
| |        || |     | |`- Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |     | `* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |     |  `* Re: Halting Problem proof refutation is a tautology thus irrefutable [ technicalolcott
| |        || |     |   +- Re: Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |     |   `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |     `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        |`* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        | `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |  `* Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman Richard Damon
| |        |   `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |    `* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        |     `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |      `* Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        |       `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |        `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        `* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| |         `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
+* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
|+- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
|`* Re: Halting Problem proof refutation is a tautology thus irrefutableolcott
| `- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
`- Re: Halting Problem proof refutation is a tautology thus irrefutableRichard Damon

Pages:1234
Halting Problem proof refutation is a tautology thus irrefutable

<d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 10:13:01 -0500
Date: Sun, 19 Jun 2022 10:13:00 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Content-Language: en-US
From: NoO...@NoWhere.com (olcott)
Subject: Halting Problem proof refutation is a tautology thus irrefutable
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 25
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-a4kBCQSKIueXFSFP36NulBtrFG/K8hZbYm5VlL1ljc0XGxM2jcjYPacuLaLF4vA7WWxU1EX1H6SMiSU!dhV6baTzQhq+ig0UXVQeAEolqOm4eAmOUUiFeVIIe09UWgtDV9VX6FiC10KwIpMXgB5IZyeRzaH4
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: 2123
 by: olcott - Sun, 19 Jun 2022 15:13 UTC

computation that halts … the Turing machine will halt whenever it enters
a final state. (Linz:1990:234)

A halt decider must compute the mapping from its inputs to an accept or
reject state on the basis of the actual behavior of these actual inputs.

When a simulating halt decider rejects all inputs as non-halting
whenever it correctly detects [in a finite number of steps] that its
correct and complete simulation of its input would never reach [a] final
state of this input then all [these] inputs (including pathological
inputs) are decided correctly.

*The above three sentences form a tautology that is proven to be true
entirely on the basis of the meaning of their words*

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

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Halting Problem proof refutation is a tautology thus irrefutable

<20220619162307.000041b2@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx08.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus
irrefutable
Message-ID: <20220619162307.000041b2@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 43
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 15:23:07 UTC
Date: Sun, 19 Jun 2022 16:23:07 +0100
X-Received-Bytes: 2153
 by: Mr Flibble - Sun, 19 Jun 2022 15:23 UTC

On Sun, 19 Jun 2022 10:13:00 -0500
olcott <NoOne@NoWhere.com> wrote:

> computation that halts … the Turing machine will halt whenever it
> enters a final state. (Linz:1990:234)
>
> A halt decider must compute the mapping from its inputs to an accept
> or reject state on the basis of the actual behavior of these actual
> inputs.
>
> When a simulating halt decider rejects all inputs as non-halting
> whenever it correctly detects [in a finite number of steps] that its
> correct and complete simulation of its input would never reach [a]
> final state of this input then all [these] inputs (including
> pathological inputs) are decided correctly.

void Px(u32 x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

....[000013e8][00102357][00000000] 83c408 add esp,+08
....[000013eb][00102353][00000000] 50 push eax
....[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
....[000013f6][00102357][00000000] 83c408 add esp,+08
....[000013f9][00102357][00000000] 33c0 xor eax,eax
....[000013fb][0010235b][00100000] 5d pop ebp
....[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

Re: Halting Problem proof refutation is a tautology thus irrefutable

<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 10:39:34 -0500
Date: Sun, 19 Jun 2022 10:39:34 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619162307.000041b2@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 82
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-S2QH6G+s1+Swm4SAEx4KvKVoez3Rm3AJxw6J2QbGnxXAvzlsMebp8fKZmACbw4lkcQASDukZbEoVxNg!jPyziAGAm/sehDT+Xjm2qSrO0MESQRz2bUeu65pqtjWFjnLJE1W9bh8k7uGchr2lbwLycB0CbUpS
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: 4503
 by: olcott - Sun, 19 Jun 2022 15:39 UTC

On 6/19/2022 10:23 AM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 10:13:00 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>>
>> A halt decider must compute the mapping from its inputs to an accept
>> or reject state on the basis of the actual behavior of these actual
>> inputs.
>>
>> When a simulating halt decider rejects all inputs as non-halting
>> whenever it correctly detects [in a finite number of steps] that its
>> correct and complete simulation of its input would never reach [a]
>> final state of this input then all [these] inputs (including
>> pathological inputs) are decided correctly.
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> ...[000013eb][00102353][00000000] 50 push eax
> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> Input_Halts = 0
> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> ...[000013fb][0010235b][00100000] 5d pop ebp
> ...[000013fc][0010235f][00000004] c3 ret
> Number of Instructions Executed(16120)
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>

_P()
[000010fa](01) 55 push ebp
[000010fb](02) 8bec mov ebp,esp
[000010fd](03) 8b4508 mov eax,[ebp+08]
[00001100](01) 50 push eax // push P
[00001101](03) 8b4d08 mov ecx,[ebp+08]
[00001104](01) 51 push ecx // push P
[00001105](05) e800feffff call 00000f0a // call H
[0000110a](03) 83c408 add esp,+08
[0000110d](02) 85c0 test eax,eax
[0000110f](02) 7402 jz 00001113
[00001111](02) ebfe jmp 00001111
[00001113](01) 5d pop ebp
[00001114](01) c3 ret
Size in bytes:(0027) [00001114]

Begin Simulation Execution Trace Stored at:211ee2
....[000010da][00211ece][00211ed2] 55 push ebp
....[000010db][00211ece][00211ed2] 8bec mov ebp,esp
....[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
....[000010e0][00211eca][000010da] 50 push eax // push P
....[000010e1][00211eca][000010da] 8b4d08 mov ecx,[ebp+08]
....[000010e4][00211ec6][000010da] 51 push ecx // push P
....[000010e5][00211ec2][000010ea] e820feffff call 00000f0a // call H
Infinitely Recursive Simulation Detected Simulation Stopped

*All technically competent software engineers* will see that when H
bases its halt status decision on whether or not its complete and
correct x86 emulation of its input would ever reach the "ret"
instruction of this input that H is correct to reject this input.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Halting Problem proof refutation is a tautology thus irrefutable

<AdmdnVutdNVm2jL_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 10:59:55 -0500
Date: Sun, 19 Jun 2022 10:59:55 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,comp.ai.philosophy
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<t8ngqq$iaj$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t8ngqq$iaj$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <AdmdnVutdNVm2jL_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 21
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ziV/2+xHr3AFOVwNA82I/N9reTEczMs50BY7hsVKJHyucr5b82XHRjzNXLNhLmVkwFhwpQSjScL+e4M!20WRQlzZ1PoOgK66mwPWPxUOkeBvfHzgx4yE5FRrWO2hArPWstzYq4TFmlI9fXxBr0zfK+caoAIg
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: 1863
 by: olcott - Sun, 19 Jun 2022 15:59 UTC

On 6/19/2022 10:54 AM, Mikko wrote:
> On 2022-06-19 15:13:00 +0000, olcott said:
>
>> computation that halts … the Turing machine will halt whenever it
>> enters a final state. (Linz:1990:234)
>
> This definition is incomplete. Therefore your refutation does not
> apply to Linz' proof.
>
> Mikko
>

It will halt whenever it reaches final state means
if and only if it reaches its final state it halts.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Halting Problem proof refutation is a tautology thus irrefutable

<20220619170111.00002570@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx09.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus
irrefutable
Message-ID: <20220619170111.00002570@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 107
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 16:01:11 UTC
Date: Sun, 19 Jun 2022 17:01:11 +0100
X-Received-Bytes: 4878
 by: Mr Flibble - Sun, 19 Jun 2022 16:01 UTC

On Sun, 19 Jun 2022 10:39:34 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 10:23 AM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 10:13:00 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> computation that halts … the Turing machine will halt whenever it
> >> enters a final state. (Linz:1990:234)
> >>
> >> A halt decider must compute the mapping from its inputs to an
> >> accept or reject state on the basis of the actual behavior of
> >> these actual inputs.
> >>
> >> When a simulating halt decider rejects all inputs as non-halting
> >> whenever it correctly detects [in a finite number of steps] that
> >> its correct and complete simulation of its input would never reach
> >> [a] final state of this input then all [these] inputs (including
> >> pathological inputs) are decided correctly.
> >
> > void Px(u32 x)
> > {
> > H(x, x);
> > return;
> > }
> >
> > int main()
> > {
> > Output("Input_Halts = ", H((u32)Px, (u32)Px));
> > }
> >
> > ...[000013e8][00102357][00000000] 83c408 add esp,+08
> > ...[000013eb][00102353][00000000] 50 push eax
> > ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> > ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> > Input_Halts = 0
> > ...[000013f6][00102357][00000000] 83c408 add esp,+08
> > ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> > ...[000013fb][0010235b][00100000] 5d pop ebp
> > ...[000013fc][0010235f][00000004] c3 ret
> > Number of Instructions Executed(16120)
> >
> > It gets the answer wrong, i.e. input has not been decided correctly.
> > QED.
> >
> > /Flibble
> >
>
> _P()
> [000010fa](01) 55 push ebp
> [000010fb](02) 8bec mov ebp,esp
> [000010fd](03) 8b4508 mov eax,[ebp+08]
> [00001100](01) 50 push eax // push P
> [00001101](03) 8b4d08 mov ecx,[ebp+08]
> [00001104](01) 51 push ecx // push P
> [00001105](05) e800feffff call 00000f0a // call H
> [0000110a](03) 83c408 add esp,+08
> [0000110d](02) 85c0 test eax,eax
> [0000110f](02) 7402 jz 00001113
> [00001111](02) ebfe jmp 00001111
> [00001113](01) 5d pop ebp
> [00001114](01) c3 ret
> Size in bytes:(0027) [00001114]
>
> Begin Simulation Execution Trace Stored at:211ee2
> ...[000010da][00211ece][00211ed2] 55 push ebp
> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
> ...[000010e0][00211eca][000010da] 50 push eax // push P
> ...[000010e1][00211eca][000010da] 8b4d08 mov ecx,[ebp+08]
> ...[000010e4][00211ec6][000010da] 51 push ecx // push P
> ...[000010e5][00211ec2][000010ea] e820feffff call 00000f0a // call H
> Infinitely Recursive Simulation Detected Simulation Stopped
>
> *All technically competent software engineers* will see that when H
> bases its halt status decision on whether or not its complete and
> correct x86 emulation of its input would ever reach the "ret"
> instruction of this input that H is correct to reject this input.

void Px(u32 x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

....[000013e8][00102357][00000000] 83c408 add esp,+08
....[000013eb][00102353][00000000] 50 push eax
....[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
....[000013f6][00102357][00000000] 83c408 add esp,+08
....[000013f9][00102357][00000000] 33c0 xor eax,eax
....[000013fb][0010235b][00100000] 5d pop ebp
....[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

Re: Halting Problem proof refutation is a tautology thus irrefutable

<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 11:23:24 -0500
Date: Sun, 19 Jun 2022 11:23:24 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619170111.00002570@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 116
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-aAB5XkFzjodQ4t0XcBHEv9ozLuyjpRKOEjfeLf4yfQ0enJFWyFYQVwfm5Ize5iTFmUlucrrDMvoNaar!BT+zut9j7DxQOPHLecr/h+mt0RZ9K68b3g+4vbwk2nNk4yPSCwxuqbgUSIZ0SLLpaxMcckbIqOPl
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: 5762
 by: olcott - Sun, 19 Jun 2022 16:23 UTC

On 6/19/2022 11:01 AM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 10:39:34 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> A halt decider must compute the mapping from its inputs to an
>>>> accept or reject state on the basis of the actual behavior of
>>>> these actual inputs.
>>>>
>>>> When a simulating halt decider rejects all inputs as non-halting
>>>> whenever it correctly detects [in a finite number of steps] that
>>>> its correct and complete simulation of its input would never reach
>>>> [a] final state of this input then all [these] inputs (including
>>>> pathological inputs) are decided correctly.
>>>
>>> void Px(u32 x)
>>> {
>>> H(x, x);
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>> }
>>>
>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>> ...[000013eb][00102353][00000000] 50 push eax
>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>> Input_Halts = 0
>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>> ...[000013fc][0010235f][00000004] c3 ret
>>> Number of Instructions Executed(16120)
>>>
>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>> QED.
>>>
>>> /Flibble
>>>
>>
>> _P()
>> [000010fa](01) 55 push ebp
>> [000010fb](02) 8bec mov ebp,esp
>> [000010fd](03) 8b4508 mov eax,[ebp+08]
>> [00001100](01) 50 push eax // push P
>> [00001101](03) 8b4d08 mov ecx,[ebp+08]
>> [00001104](01) 51 push ecx // push P
>> [00001105](05) e800feffff call 00000f0a // call H
>> [0000110a](03) 83c408 add esp,+08
>> [0000110d](02) 85c0 test eax,eax
>> [0000110f](02) 7402 jz 00001113
>> [00001111](02) ebfe jmp 00001111
>> [00001113](01) 5d pop ebp
>> [00001114](01) c3 ret
>> Size in bytes:(0027) [00001114]
>>
>> Begin Simulation Execution Trace Stored at:211ee2
>> ...[000010da][00211ece][00211ed2] 55 push ebp
>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
>> ...[000010e0][00211eca][000010da] 50 push eax // push P
>> ...[000010e1][00211eca][000010da] 8b4d08 mov ecx,[ebp+08]
>> ...[000010e4][00211ec6][000010da] 51 push ecx // push P
>> ...[000010e5][00211ec2][000010ea] e820feffff call 00000f0a // call H
>> Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> *All technically competent software engineers* will see that when H
>> bases its halt status decision on whether or not its complete and
>> correct x86 emulation of its input would ever reach the "ret"
>> instruction of this input that H is correct to reject this input.
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> ...[000013eb][00102353][00000000] 50 push eax
> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> Input_Halts = 0
> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> ...[000013fb][0010235b][00100000] 5d pop ebp
> ...[000013fc][0010235f][00000004] c3 ret
> Number of Instructions Executed(16120)
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>

*All technically competent software engineers*

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Halting Problem proof refutation is a tautology thus irrefutable

<moIrK.3621$El2.175@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 39
Message-ID: <moIrK.3621$El2.175@fx45.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: Sun, 19 Jun 2022 12:45:06 -0400
X-Received-Bytes: 2635
 by: Richard Damon - Sun, 19 Jun 2022 16:45 UTC

On 6/19/22 11:13 AM, olcott wrote:
> computation that halts … the Turing machine will halt whenever it enters
> a final state. (Linz:1990:234)
>
> A halt decider must compute the mapping from its inputs to an accept or
> reject state on the basis of the actual behavior of these actual inputs.

And the call H(P,P) must be asking about the actual behavior of P(P) or
your P isn't built by the actual requirements of the Linz prrof.

>
> When a simulating halt decider rejects all inputs as non-halting
> whenever it correctly detects [in a finite number of steps] that its
> correct and complete simulation of its input would never reach [a] final
> state of this input then all [these] inputs (including pathological
> inputs) are decided correctly.

Except the decision needs to be CORRECT, based on what a CORRECT
simulation would do, which BY DEFINITION, matches the behaivor of the
program that it represents.

>
> *The above three sentences form a tautology that is proven to be true
> entirely on the basis of the meaning of their words*

Except that you never actually meet the requirements of its premises.

Since there does not exist a finite pattern in the execution trace of
P(P) that the H(P,P) that it uses can have that actually shows
non-halting behavior, as any pattern that is put into that H that
appears in the execution of P(P) causes that H(P,P) to return 0 to its
calling P(P) which makes that, and thus ALL, P(P)s halt.

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

Re: Halting Problem proof refutation is a tautology thus irrefutable

<LqIrK.3622$El2.1653@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!border1.nntp.dca1.giganews.com!nntp.giganews.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 91
Message-ID: <LqIrK.3622$El2.1653@fx45.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: Sun, 19 Jun 2022 12:47:39 -0400
X-Received-Bytes: 5016
X-Original-Bytes: 4883
 by: Richard Damon - Sun, 19 Jun 2022 16:47 UTC

On 6/19/22 11:39 AM, olcott wrote:
> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>> On Sun, 19 Jun 2022 10:13:00 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>>
>>> A halt decider must compute the mapping from its inputs to an accept
>>> or reject state on the basis of the actual behavior of these actual
>>> inputs.
>>>
>>> When a simulating halt decider rejects all inputs as non-halting
>>> whenever it correctly detects [in a finite number of steps] that its
>>> correct and complete simulation of its input would never reach [a]
>>> final state of this input then all [these] inputs (including
>>> pathological inputs) are decided correctly.
>>
>> void Px(u32 x)
>> {
>>     H(x, x);
>>     return;
>> }
>>
>> int main()
>> {
>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>> }
>>
>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>> ...[000013eb][00102353][00000000] 50              push eax
>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>> Input_Halts = 0
>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>> ...[000013fc][0010235f][00000004] c3              ret
>> Number of Instructions Executed(16120)
>>
>> It gets the answer wrong, i.e. input has not been decided correctly.
>> QED.
>>
>> /Flibble
>>
>
> _P()
> [000010fa](01)  55              push ebp
> [000010fb](02)  8bec            mov ebp,esp
> [000010fd](03)  8b4508          mov eax,[ebp+08]
> [00001100](01)  50              push eax       // push P
> [00001101](03)  8b4d08          mov ecx,[ebp+08]
> [00001104](01)  51              push ecx       // push P
> [00001105](05)  e800feffff      call 00000f0a  // call H
> [0000110a](03)  83c408          add esp,+08
> [0000110d](02)  85c0            test eax,eax
> [0000110f](02)  7402            jz 00001113
> [00001111](02)  ebfe            jmp 00001111
> [00001113](01)  5d              pop ebp
> [00001114](01)  c3              ret
> Size in bytes:(0027) [00001114]
>
> Begin Simulation   Execution Trace Stored at:211ee2
> ...[000010da][00211ece][00211ed2] 55         push ebp
> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
> ...[000010e0][00211eca][000010da] 50         push eax      // push P
> ...[000010e1][00211eca][000010da] 8b4d08     mov ecx,[ebp+08]
> ...[000010e4][00211ec6][000010da] 51         push ecx      // push P
> ...[000010e5][00211ec2][000010ea] e820feffff call 00000f0a // call H
> Infinitely Recursive Simulation Detected Simulation Stopped
>
> *All technically competent software engineers* will see that when H
> bases its halt status decision on whether or not its complete and
> correct x86 emulation of its input would ever reach the "ret"
> instruction of this input that H is correct to reject this input.
>

So, does it do a complete and correct emulation (and thus never aborts
so never returns the value 0) or does it not do a complete and correct
emulation so it can return 0 and thus has no true premise to base its
logic on.

Your arguement makes the flaw of assuming an impossible condition, that
H CAN do both a correct and complete emulation and at the same time
return the value 0.

Either you need to do infinite work in finite time or you are doing
something incorrectly and have unsound logic.

FAIL.

Re: Halting Problem proof refutation is a tautology thus irrefutable

<rrIrK.3623$El2.1164@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 7
Message-ID: <rrIrK.3623$El2.1164@fx45.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: Sun, 19 Jun 2022 12:48:23 -0400
X-Received-Bytes: 1226
 by: Richard Damon - Sun, 19 Jun 2022 16:48 UTC

On 6/19/22 12:23 PM, olcott wrote:

> *All technically competent software engineers*
>

Which means you are excluding yourself.

Re: Halting Problem proof refutation is a tautology thus irrefutable

<stIrK.3624$El2.1617@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic comp.ai.philosophy
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,comp.ai.philosophy
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<t8ngqq$iaj$1@dont-email.me> <AdmdnVutdNVm2jL_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <AdmdnVutdNVm2jL_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 23
Message-ID: <stIrK.3624$El2.1617@fx45.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: Sun, 19 Jun 2022 12:50:31 -0400
X-Received-Bytes: 1738
 by: Richard Damon - Sun, 19 Jun 2022 16:50 UTC

On 6/19/22 11:59 AM, olcott wrote:
> On 6/19/2022 10:54 AM, Mikko wrote:
>> On 2022-06-19 15:13:00 +0000, olcott said:
>>
>>> computation that halts … the Turing machine will halt whenever it
>>> enters a final state. (Linz:1990:234)
>>
>> This definition is incomplete. Therefore your refutation does not
>> apply to Linz' proof.
>>
>> Mikko
>>
>
> It will halt whenever it reaches final state means
> if and only if it reaches its final state it halts.
>

But it needs to also include the fact that non-halting means that it
never reaches the final state without running for an unbounded number of
steps.

The definition as quoted presumes that nothing "pauses or stops" the
execution of the Turing Machine.

Re: Halting Problem proof refutation is a tautology thus irrefutable

<20220619180139.000016fd@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder.usenetexpress.com!tr3.eu1.usenetexpress.com!81.171.65.13.MISMATCH!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx04.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Message-ID: <20220619180139.000016fd@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com> <20220619162307.000041b2@reddwarf.jmc> <--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com> <20220619170111.00002570@reddwarf.jmc> <JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 141
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 17:01:38 UTC
Date: Sun, 19 Jun 2022 18:01:39 +0100
X-Received-Bytes: 6224
 by: Mr Flibble - Sun, 19 Jun 2022 17:01 UTC

On Sun, 19 Jun 2022 11:23:24 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 11:01 AM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 10:39:34 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 10:23 AM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 10:13:00 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> computation that halts … the Turing machine will halt whenever it
> >>>> enters a final state. (Linz:1990:234)
> >>>>
> >>>> A halt decider must compute the mapping from its inputs to an
> >>>> accept or reject state on the basis of the actual behavior of
> >>>> these actual inputs.
> >>>>
> >>>> When a simulating halt decider rejects all inputs as non-halting
> >>>> whenever it correctly detects [in a finite number of steps] that
> >>>> its correct and complete simulation of its input would never
> >>>> reach [a] final state of this input then all [these] inputs
> >>>> (including pathological inputs) are decided correctly.
> >>>
> >>> void Px(u32 x)
> >>> {
> >>> H(x, x);
> >>> return;
> >>> }
> >>>
> >>> int main()
> >>> {
> >>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>> }
> >>>
> >>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >>> ...[000013eb][00102353][00000000] 50 push eax
> >>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> >>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> >>> Input_Halts = 0
> >>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>> ...[000013fc][0010235f][00000004] c3 ret
> >>> Number of Instructions Executed(16120)
> >>>
> >>> It gets the answer wrong, i.e. input has not been decided
> >>> correctly. QED.
> >>>
> >>> /Flibble
> >>>
> >>
> >> _P()
> >> [000010fa](01) 55 push ebp
> >> [000010fb](02) 8bec mov ebp,esp
> >> [000010fd](03) 8b4508 mov eax,[ebp+08]
> >> [00001100](01) 50 push eax // push P
> >> [00001101](03) 8b4d08 mov ecx,[ebp+08]
> >> [00001104](01) 51 push ecx // push P
> >> [00001105](05) e800feffff call 00000f0a // call H
> >> [0000110a](03) 83c408 add esp,+08
> >> [0000110d](02) 85c0 test eax,eax
> >> [0000110f](02) 7402 jz 00001113
> >> [00001111](02) ebfe jmp 00001111
> >> [00001113](01) 5d pop ebp
> >> [00001114](01) c3 ret
> >> Size in bytes:(0027) [00001114]
> >>
> >> Begin Simulation Execution Trace Stored at:211ee2
> >> ...[000010da][00211ece][00211ed2] 55 push ebp
> >> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
> >> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
> >> ...[000010e0][00211eca][000010da] 50 push eax // push
> >> P ...[000010e1][00211eca][000010da] 8b4d08 mov ecx,[ebp+08]
> >> ...[000010e4][00211ec6][000010da] 51 push ecx // push
> >> P ...[000010e5][00211ec2][000010ea] e820feffff call 00000f0a //
> >> call H Infinitely Recursive Simulation Detected Simulation Stopped
> >>
> >> *All technically competent software engineers* will see that when H
> >> bases its halt status decision on whether or not its complete and
> >> correct x86 emulation of its input would ever reach the "ret"
> >> instruction of this input that H is correct to reject this input.
> >
> > void Px(u32 x)
> > {
> > H(x, x);
> > return;
> > }
> >
> > int main()
> > {
> > Output("Input_Halts = ", H((u32)Px, (u32)Px));
> > }
> >
> > ...[000013e8][00102357][00000000] 83c408 add esp,+08
> > ...[000013eb][00102353][00000000] 50 push eax
> > ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> > ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> > Input_Halts = 0
> > ...[000013f6][00102357][00000000] 83c408 add esp,+08
> > ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> > ...[000013fb][0010235b][00100000] 5d pop ebp
> > ...[000013fc][0010235f][00000004] c3 ret
> > Number of Instructions Executed(16120)
> >
> > It gets the answer wrong, i.e. input has not been decided correctly.
> > QED.
> >
> > /Flibble
> >
>
> *All technically competent software engineers*
void Px(u32 x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

....[000013e8][00102357][00000000] 83c408 add esp,+08
....[000013eb][00102353][00000000] 50 push eax
....[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
....[000013f6][00102357][00000000] 83c408 add esp,+08
....[000013f9][00102357][00000000] 33c0 xor eax,eax
....[000013fb][0010235b][00100000] 5d pop ebp
....[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

Re: Halting Problem proof refutation is a tautology thus irrefutable

<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 12:16:05 -0500
Date: Sun, 19 Jun 2022 12:16:05 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619180139.000016fd@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 156
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-oNnAhrOp14myX4JraBMfxnikfszSG12h/FsvV8Qa+osv0ZTmtO62OKLuprZWnsUzvvqdB9cA54CBhim!qlbj0d5ltAiRmSLvP63oKP/XprWo8TFiZag3AXKLtNo44+udM1y3a+3MRn1Ez8REg+W3GlSqwaKv
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: 7426
 by: olcott - Sun, 19 Jun 2022 17:16 UTC

On 6/19/2022 12:01 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 11:23:24 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>> enters a final state. (Linz:1990:234)
>>>>>>
>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>> these actual inputs.
>>>>>>
>>>>>> When a simulating halt decider rejects all inputs as non-halting
>>>>>> whenever it correctly detects [in a finite number of steps] that
>>>>>> its correct and complete simulation of its input would never
>>>>>> reach [a] final state of this input then all [these] inputs
>>>>>> (including pathological inputs) are decided correctly.
>>>>>
>>>>> void Px(u32 x)
>>>>> {
>>>>> H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>> }
>>>>>
>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>>>> Input_Halts = 0
>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>>>> ...[000013fc][0010235f][00000004] c3 ret
>>>>> Number of Instructions Executed(16120)
>>>>>
>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>> correctly. QED.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> _P()
>>>> [000010fa](01) 55 push ebp
>>>> [000010fb](02) 8bec mov ebp,esp
>>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
>>>> [00001100](01) 50 push eax // push P
>>>> [00001101](03) 8b4d08 mov ecx,[ebp+08]
>>>> [00001104](01) 51 push ecx // push P
>>>> [00001105](05) e800feffff call 00000f0a // call H
>>>> [0000110a](03) 83c408 add esp,+08
>>>> [0000110d](02) 85c0 test eax,eax
>>>> [0000110f](02) 7402 jz 00001113
>>>> [00001111](02) ebfe jmp 00001111
>>>> [00001113](01) 5d pop ebp
>>>> [00001114](01) c3 ret
>>>> Size in bytes:(0027) [00001114]
>>>>
>>>> Begin Simulation Execution Trace Stored at:211ee2
>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
>>>> ...[000010e0][00211eca][000010da] 50 push eax // push
>>>> P ...[000010e1][00211eca][000010da] 8b4d08 mov ecx,[ebp+08]
>>>> ...[000010e4][00211ec6][000010da] 51 push ecx // push
>>>> P ...[000010e5][00211ec2][000010ea] e820feffff call 00000f0a //
>>>> call H Infinitely Recursive Simulation Detected Simulation Stopped
>>>>
>>>> *All technically competent software engineers* will see that when H
>>>> bases its halt status decision on whether or not its complete and
>>>> correct x86 emulation of its input would ever reach the "ret"
>>>> instruction of this input that H is correct to reject this input.
>>>
>>> void Px(u32 x)
>>> {
>>> H(x, x);
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>> }
>>>
>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>> ...[000013eb][00102353][00000000] 50 push eax
>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>> Input_Halts = 0
>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>> ...[000013fc][0010235f][00000004] c3 ret
>>> Number of Instructions Executed(16120)
>>>
>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>> QED.
>>>
>>> /Flibble
>>>
>>
>> *All technically competent software engineers*
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> ...[000013eb][00102353][00000000] 50 push eax
> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> Input_Halts = 0
> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> ...[000013fb][0010235b][00100000] 5d pop ebp
> ...[000013fc][0010235f][00000004] c3 ret
> Number of Instructions Executed(16120)
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>

Because it is an easily verified fact that the correct and complete x86
emulation of the input to H(P,P) by H would never reach the "ret"
instruction of P and this is the criterion measure for H to reject its
input how do you figure that H gets the wrong answer?

What I am saying is a logical tautology the same as when we know that X
is a black cat then we know that X is a cat.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Halting Problem proof refutation is a tautology thus irrefutable

<07JrK.3625$El2.588@fx45.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx45.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 155
Message-ID: <07JrK.3625$El2.588@fx45.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: Sun, 19 Jun 2022 13:34:51 -0400
X-Received-Bytes: 7927
 by: Richard Damon - Sun, 19 Jun 2022 17:34 UTC

On 6/19/22 1:16 PM, olcott wrote:
> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>> On Sun, 19 Jun 2022 11:23:24 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> computation that halts … the Turing machine will halt whenever it
>>>>>>> enters a final state. (Linz:1990:234)
>>>>>>>
>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>> these actual inputs.
>>>>>>>
>>>>>>> When a simulating halt decider rejects all inputs as non-halting
>>>>>>> whenever it correctly detects [in a finite number of steps] that
>>>>>>> its correct and complete simulation of its input would never
>>>>>>> reach [a] final state of this input then all [these] inputs
>>>>>>> (including pathological inputs) are decided correctly.
>>>>>>
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>>       H(x, x);
>>>>>>       return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>> }
>>>>>>
>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>> Input_Halts = 0
>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>> Number of Instructions Executed(16120)
>>>>>>
>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>> correctly. QED.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> _P()
>>>>> [000010fa](01)  55              push ebp
>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>> [00001100](01)  50              push eax       // push P
>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>> [00001104](01)  51              push ecx       // push P
>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>> [0000110a](03)  83c408          add esp,+08
>>>>> [0000110d](02)  85c0            test eax,eax
>>>>> [0000110f](02)  7402            jz 00001113
>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>> [00001113](01)  5d              pop ebp
>>>>> [00001114](01)  c3              ret
>>>>> Size in bytes:(0027) [00001114]
>>>>>
>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
>>>>> ...[000010e0][00211eca][000010da] 50         push eax      // push
>>>>> P ...[000010e1][00211eca][000010da] 8b4d08     mov ecx,[ebp+08]
>>>>> ...[000010e4][00211ec6][000010da] 51         push ecx      // push
>>>>> P ...[000010e5][00211ec2][000010ea] e820feffff call 00000f0a //
>>>>> call H Infinitely Recursive Simulation Detected Simulation Stopped
>>>>>
>>>>> *All technically competent software engineers* will see that when H
>>>>> bases its halt status decision on whether or not its complete and
>>>>> correct x86 emulation of its input would ever reach the "ret"
>>>>> instruction of this input that H is correct to reject this input.
>>>>
>>>> void Px(u32 x)
>>>> {
>>>>      H(x, x);
>>>>      return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>> }
>>>>
>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>> Input_Halts = 0
>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>> Number of Instructions Executed(16120)
>>>>
>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>> QED.
>>>>
>>>> /Flibble
>>>
>>> *All technically competent software engineers*
>> void Px(u32 x)
>> {
>>     H(x, x);
>>     return;
>> }
>>
>> int main()
>> {
>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>> }
>>
>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>> ...[000013eb][00102353][00000000] 50              push eax
>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>> Input_Halts = 0
>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>> ...[000013fc][0010235f][00000004] c3              ret
>> Number of Instructions Executed(16120)
>>
>> It gets the answer wrong, i.e. input has not been decided correctly.
>> QED.
>>
>> /Flibble
>>
>
> Because it is an easily verified fact that the correct and complete x86
> emulation of the input to H(P,P) by H would never reach the "ret"
> instruction of P and this is the criterion measure for H to reject its
> input how do you figure that H gets the wrong answer?
>
> What I am saying is a logical tautology the same as when we know that X
> is a black cat then we know that X is a cat.
>

No, your "proof" of this is based on the assumption that H itself does a
complete and correct emulation of its input. SInce it doesn't if it
returns 0 from H(P,P), that proof doesn't apply.

Your logic is unsound.

You have an impossible to meet definition of an algorithm to put into H,
so it doesn't actually exist.

Re: Halting Problem proof refutation is a tautology thus irrefutable

<20220619184006.00002392@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx12.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus
irrefutable
Message-ID: <20220619184006.00002392@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 188
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 17:40:05 UTC
Date: Sun, 19 Jun 2022 18:40:06 +0100
X-Received-Bytes: 8195
 by: Mr Flibble - Sun, 19 Jun 2022 17:40 UTC

On Sun, 19 Jun 2022 12:16:05 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 12:01 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 11:23:24 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 11:01 AM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 10:39:34 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 10:13:00 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> computation that halts … the Turing machine will halt whenever
> >>>>>> it enters a final state. (Linz:1990:234)
> >>>>>>
> >>>>>> A halt decider must compute the mapping from its inputs to an
> >>>>>> accept or reject state on the basis of the actual behavior of
> >>>>>> these actual inputs.
> >>>>>>
> >>>>>> When a simulating halt decider rejects all inputs as
> >>>>>> non-halting whenever it correctly detects [in a finite number
> >>>>>> of steps] that its correct and complete simulation of its
> >>>>>> input would never reach [a] final state of this input then all
> >>>>>> [these] inputs (including pathological inputs) are decided
> >>>>>> correctly.
> >>>>>
> >>>>> void Px(u32 x)
> >>>>> {
> >>>>> H(x, x);
> >>>>> return;
> >>>>> }
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>> }
> >>>>>
> >>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >>>>> ...[000013eb][00102353][00000000] 50 push eax
> >>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> >>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> >>>>> Input_Halts = 0
> >>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>>>> ...[000013fc][0010235f][00000004] c3 ret
> >>>>> Number of Instructions Executed(16120)
> >>>>>
> >>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>> correctly. QED.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> _P()
> >>>> [000010fa](01) 55 push ebp
> >>>> [000010fb](02) 8bec mov ebp,esp
> >>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
> >>>> [00001100](01) 50 push eax // push P
> >>>> [00001101](03) 8b4d08 mov ecx,[ebp+08]
> >>>> [00001104](01) 51 push ecx // push P
> >>>> [00001105](05) e800feffff call 00000f0a // call H
> >>>> [0000110a](03) 83c408 add esp,+08
> >>>> [0000110d](02) 85c0 test eax,eax
> >>>> [0000110f](02) 7402 jz 00001113
> >>>> [00001111](02) ebfe jmp 00001111
> >>>> [00001113](01) 5d pop ebp
> >>>> [00001114](01) c3 ret
> >>>> Size in bytes:(0027) [00001114]
> >>>>
> >>>> Begin Simulation Execution Trace Stored at:211ee2
> >>>> ...[000010da][00211ece][00211ed2] 55 push ebp
> >>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
> >>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
> >>>> ...[000010e0][00211eca][000010da] 50 push eax //
> >>>> push P ...[000010e1][00211eca][000010da] 8b4d08 mov
> >>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
> >>>> ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff
> >>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
> >>>> Simulation Stopped
> >>>>
> >>>> *All technically competent software engineers* will see that
> >>>> when H bases its halt status decision on whether or not its
> >>>> complete and correct x86 emulation of its input would ever reach
> >>>> the "ret" instruction of this input that H is correct to reject
> >>>> this input.
> >>>
> >>> void Px(u32 x)
> >>> {
> >>> H(x, x);
> >>> return;
> >>> }
> >>>
> >>> int main()
> >>> {
> >>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>> }
> >>>
> >>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> >>> ...[000013eb][00102353][00000000] 50 push eax
> >>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> >>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> >>> Input_Halts = 0
> >>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> >>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> >>> ...[000013fb][0010235b][00100000] 5d pop ebp
> >>> ...[000013fc][0010235f][00000004] c3 ret
> >>> Number of Instructions Executed(16120)
> >>>
> >>> It gets the answer wrong, i.e. input has not been decided
> >>> correctly. QED.
> >>>
> >>> /Flibble
> >>>
> >>
> >> *All technically competent software engineers*
> >
> > void Px(u32 x)
> > {
> > H(x, x);
> > return;
> > }
> >
> > int main()
> > {
> > Output("Input_Halts = ", H((u32)Px, (u32)Px));
> > }
> >
> > ...[000013e8][00102357][00000000] 83c408 add esp,+08
> > ...[000013eb][00102353][00000000] 50 push eax
> > ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> > ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> > Input_Halts = 0
> > ...[000013f6][00102357][00000000] 83c408 add esp,+08
> > ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> > ...[000013fb][0010235b][00100000] 5d pop ebp
> > ...[000013fc][0010235f][00000004] c3 ret
> > Number of Instructions Executed(16120)
> >
> > It gets the answer wrong, i.e. input has not been decided correctly.
> > QED.
> >
> > /Flibble
> >
>
> Because it is an easily verified fact that the correct and complete
> x86 emulation of the input to H(P,P) by H would never reach the "ret"
> instruction of P and this is the criterion measure for H to reject
> its input how do you figure that H gets the wrong answer?
>
> What I am saying is a logical tautology the same as when we know that
> X is a black cat then we know that X is a cat.
We are talking about Px, not P. We are talking about your H not
analysing what its input actually does and instead assuming that an
input that calls H is always pathological.

void Px(u32 x)
{ H(x, x);
return;
}

int main()
{ Output("Input_Halts = ", H((u32)Px, (u32)Px));
}

....[000013e8][00102357][00000000] 83c408 add esp,+08
....[000013eb][00102353][00000000] 50 push eax
....[000013ec][0010234f][00000427] 6827040000 push 00000427
---[000013f1][0010234f][00000427] e880f0ffff call 00000476
Input_Halts = 0
....[000013f6][00102357][00000000] 83c408 add esp,+08
....[000013f9][00102357][00000000] 33c0 xor eax,eax
....[000013fb][0010235b][00100000] 5d pop ebp
....[000013fc][0010235f][00000004] c3 ret
Number of Instructions Executed(16120)

It gets the answer wrong, i.e. input has not been decided correctly.
QED.

/Flibble

Re: Halting Problem proof refutation is a tautology thus irrefutable

<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 13:08:03 -0500
Date: Sun, 19 Jun 2022 13:08:03 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619184006.00002392@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 199
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-nJSdcpjFYPkn6hieVPq/hQnjWY/9Z4rKIhdmPVlwfpXcc8kPFUpEvVJV+SA67Mv452mfx/J/Rvqfu+N!obIjDbpH+0m8oiaP5oNjuxAze/rtpYlT2SK3yUYzOoZoQcsRxufMrEW5GdclMLjwSgafEQrzInc/
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: 9170
 by: olcott - Sun, 19 Jun 2022 18:08 UTC

On 6/19/2022 12:40 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 12:16:05 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>
>>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>>> these actual inputs.
>>>>>>>>
>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>> non-halting whenever it correctly detects [in a finite number
>>>>>>>> of steps] that its correct and complete simulation of its
>>>>>>>> input would never reach [a] final state of this input then all
>>>>>>>> [these] inputs (including pathological inputs) are decided
>>>>>>>> correctly.
>>>>>>>
>>>>>>> void Px(u32 x)
>>>>>>> {
>>>>>>> H(x, x);
>>>>>>> return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>> }
>>>>>>>
>>>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>>>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>>>>>> Input_Halts = 0
>>>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>>>>>> ...[000013fc][0010235f][00000004] c3 ret
>>>>>>> Number of Instructions Executed(16120)
>>>>>>>
>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>> correctly. QED.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> _P()
>>>>>> [000010fa](01) 55 push ebp
>>>>>> [000010fb](02) 8bec mov ebp,esp
>>>>>> [000010fd](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001100](01) 50 push eax // push P
>>>>>> [00001101](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [00001104](01) 51 push ecx // push P
>>>>>> [00001105](05) e800feffff call 00000f0a // call H
>>>>>> [0000110a](03) 83c408 add esp,+08
>>>>>> [0000110d](02) 85c0 test eax,eax
>>>>>> [0000110f](02) 7402 jz 00001113
>>>>>> [00001111](02) ebfe jmp 00001111
>>>>>> [00001113](01) 5d pop ebp
>>>>>> [00001114](01) c3 ret
>>>>>> Size in bytes:(0027) [00001114]
>>>>>>
>>>>>> Begin Simulation Execution Trace Stored at:211ee2
>>>>>> ...[000010da][00211ece][00211ed2] 55 push ebp
>>>>>> ...[000010db][00211ece][00211ed2] 8bec mov ebp,esp
>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508 mov eax,[ebp+08]
>>>>>> ...[000010e0][00211eca][000010da] 50 push eax //
>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08 mov
>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51 push
>>>>>> ecx // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
>>>>>> Simulation Stopped
>>>>>>
>>>>>> *All technically competent software engineers* will see that
>>>>>> when H bases its halt status decision on whether or not its
>>>>>> complete and correct x86 emulation of its input would ever reach
>>>>>> the "ret" instruction of this input that H is correct to reject
>>>>>> this input.
>>>>>
>>>>> void Px(u32 x)
>>>>> {
>>>>> H(x, x);
>>>>> return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>> }
>>>>>
>>>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>>>> ...[000013eb][00102353][00000000] 50 push eax
>>>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>>>> Input_Halts = 0
>>>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>>>> ...[000013fc][0010235f][00000004] c3 ret
>>>>> Number of Instructions Executed(16120)
>>>>>
>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>> correctly. QED.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> *All technically competent software engineers*
>>>
>>> void Px(u32 x)
>>> {
>>> H(x, x);
>>> return;
>>> }
>>>
>>> int main()
>>> {
>>> Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>> }
>>>
>>> ...[000013e8][00102357][00000000] 83c408 add esp,+08
>>> ...[000013eb][00102353][00000000] 50 push eax
>>> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
>>> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
>>> Input_Halts = 0
>>> ...[000013f6][00102357][00000000] 83c408 add esp,+08
>>> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
>>> ...[000013fb][0010235b][00100000] 5d pop ebp
>>> ...[000013fc][0010235f][00000004] c3 ret
>>> Number of Instructions Executed(16120)
>>>
>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>> QED.
>>>
>>> /Flibble
>>>
>>
>> Because it is an easily verified fact that the correct and complete
>> x86 emulation of the input to H(P,P) by H would never reach the "ret"
>> instruction of P and this is the criterion measure for H to reject
>> its input how do you figure that H gets the wrong answer?
>>
>> What I am saying is a logical tautology the same as when we know that
>> X is a black cat then we know that X is a cat.
>
> We are talking about Px, not P. We are talking about your H not
> analysing what its input actually does and instead assuming that an
> input that calls H is always pathological.
>
> void Px(u32 x)
> {
> H(x, x);
> return;
> }
>
> int main()
> {
> Output("Input_Halts = ", H((u32)Px, (u32)Px));
> }
>
> ...[000013e8][00102357][00000000] 83c408 add esp,+08
> ...[000013eb][00102353][00000000] 50 push eax
> ...[000013ec][0010234f][00000427] 6827040000 push 00000427
> ---[000013f1][0010234f][00000427] e880f0ffff call 00000476
> Input_Halts = 0
> ...[000013f6][00102357][00000000] 83c408 add esp,+08
> ...[000013f9][00102357][00000000] 33c0 xor eax,eax
> ...[000013fb][0010235b][00100000] 5d pop ebp
> ...[000013fc][0010235f][00000004] c3 ret
> Number of Instructions Executed(16120)
>
> It gets the answer wrong, i.e. input has not been decided correctly.
> QED.
>
> /Flibble
>


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable

<lpudnftnnOD1-zL_nZ2dnUU7_8z8fwAA@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 13:09:44 -0500
Date: Sun, 19 Jun 2022 13:09:44 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<t8ngqq$iaj$1@dont-email.me> <AdmdnVutdNVm2jL_nZ2dnUU7_8xh4p2d@giganews.com>
<t8nmoq$tj4$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t8nmoq$tj4$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <lpudnftnnOD1-zL_nZ2dnUU7_8z8fwAA@giganews.com>
Lines: 31
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Tz1lnj9NtfmDJHATDAQ7T8YA0PQdlcFSK8vYy/vAFoC7rHBg6tHLaHZI6mexYbKiy6Inlr9OUOVC83a!viz173HOb7bEauTfwAyOHtunFe8PZWO9P6qhqYeu5BaxxZFwfKXn7vqGvzpIz7V6m9m3Jofnqbus
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: 2152
 by: olcott - Sun, 19 Jun 2022 18:09 UTC

On 6/19/2022 12:35 PM, Mikko wrote:
> On 2022-06-19 15:59:55 +0000, olcott said:
>
>> On 6/19/2022 10:54 AM, Mikko wrote:
>>> On 2022-06-19 15:13:00 +0000, olcott said:
>>>
>>>> computation that halts … the Turing machine will halt whenever it
>>>> enters a final state. (Linz:1990:234)
>>>
>>> This definition is incomplete. Therefore your refutation does not
>>> apply to Linz' proof.
>>>
>>> Mikko
>>>
>>
>> It will halt whenever it reaches final state means
>> if and only if it reaches its final state it halts.
>
> Dosn't matter if you can't write a publishable proof.
>
> Mikko
>

The code <is> the proof.

--
Copyright 2022 Pete Olcott

"Talent hits a target no one else can hit;
Genius hits a target no one else can see."
Arthur Schopenhauer

Re: Halting Problem proof refutation is a tautology thus irrefutable

<CNJrK.175022$JVi.9534@fx17.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
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!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx17.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 196
Message-ID: <CNJrK.175022$JVi.9534@fx17.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: Sun, 19 Jun 2022 14:20:17 -0400
X-Received-Bytes: 9830
 by: Richard Damon - Sun, 19 Jun 2022 18:20 UTC

On 6/19/22 2:08 PM, olcott wrote:
> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>> On Sun, 19 Jun 2022 12:16:05 -0500
>> olcott <NoOne@NoWhere.com> wrote:
>>
>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>
>>>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>>>> these actual inputs.
>>>>>>>>>
>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>> non-halting whenever it correctly detects [in a finite number
>>>>>>>>> of steps] that its correct and complete simulation of its
>>>>>>>>> input would never reach [a] final state of this input then all
>>>>>>>>> [these] inputs (including pathological inputs) are decided
>>>>>>>>> correctly.
>>>>>>>>
>>>>>>>> void Px(u32 x)
>>>>>>>> {
>>>>>>>>        H(x, x);
>>>>>>>>        return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>> }
>>>>>>>>
>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>> Input_Halts = 0
>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>
>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>> correctly. QED.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> _P()
>>>>>>> [000010fa](01)  55              push ebp
>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>> [00001114](01)  c3              ret
>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>
>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
>>>>>>> ...[000010e0][00211eca][000010da] 50         push eax      //
>>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08     mov
>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51         push
>>>>>>> ecx      // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
>>>>>>> Simulation Stopped
>>>>>>>
>>>>>>> *All technically competent software engineers* will see that
>>>>>>> when H bases its halt status decision on whether or not its
>>>>>>> complete and correct x86 emulation of its input would ever reach
>>>>>>> the "ret" instruction of this input that H is correct to reject
>>>>>>> this input.
>>>>>>
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>>       H(x, x);
>>>>>>       return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>> }
>>>>>>
>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>> Input_Halts = 0
>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>> Number of Instructions Executed(16120)
>>>>>>
>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>> correctly. QED.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> *All technically competent software engineers*
>>>> void Px(u32 x)
>>>> {
>>>>      H(x, x);
>>>>      return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>> }
>>>>
>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>> Input_Halts = 0
>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>> Number of Instructions Executed(16120)
>>>>
>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>> QED.
>>>>
>>>> /Flibble
>>>
>>> Because it is an easily verified fact that the correct and complete
>>> x86 emulation of the input to H(P,P) by H would never reach the "ret"
>>> instruction of P and this is the criterion measure for H to reject
>>> its input how do you figure that H gets the wrong answer?
>>>
>>> What I am saying is a logical tautology the same as when we know that
>>> X is a black cat then we know that X is a cat.
>> We are talking about Px, not P. We are talking about your H not
>> analysing what its input actually does and instead assuming that an
>> input that calls H is always pathological.
>>
>> void Px(u32 x)
>> {
>>     H(x, x);
>>     return;
>> }
>>
>> int main()
>> {
>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>> }
>>
>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>> ...[000013eb][00102353][00000000] 50              push eax
>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>> Input_Halts = 0
>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>> ...[000013fc][0010235f][00000004] c3              ret
>> Number of Instructions Executed(16120)
>>
>> It gets the answer wrong, i.e. input has not been decided correctly.
>> QED.
>>
>> /Flibble
>>
>
> DO YOU AGREE WITH THIS?
> H(Px,Px) does correctly determine that the complete and correct x86
> emulation of its input would never reach the "ret" instruction of Px.
>


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable

<FPJrK.175023$JVi.116301@fx17.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx17.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<t8ngqq$iaj$1@dont-email.me> <AdmdnVutdNVm2jL_nZ2dnUU7_8xh4p2d@giganews.com>
<t8nmoq$tj4$1@dont-email.me> <lpudnftnnOD1-zL_nZ2dnUU7_8z8fwAA@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <lpudnftnnOD1-zL_nZ2dnUU7_8z8fwAA@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 33
Message-ID: <FPJrK.175023$JVi.116301@fx17.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: Sun, 19 Jun 2022 14:22:29 -0400
X-Received-Bytes: 2219
 by: Richard Damon - Sun, 19 Jun 2022 18:22 UTC

On 6/19/22 2:09 PM, olcott wrote:
> On 6/19/2022 12:35 PM, Mikko wrote:
>> On 2022-06-19 15:59:55 +0000, olcott said:
>>
>>> On 6/19/2022 10:54 AM, Mikko wrote:
>>>> On 2022-06-19 15:13:00 +0000, olcott said:
>>>>
>>>>> computation that halts … the Turing machine will halt whenever it
>>>>> enters a final state. (Linz:1990:234)
>>>>
>>>> This definition is incomplete. Therefore your refutation does not
>>>> apply to Linz' proof.
>>>>
>>>> Mikko
>>>>
>>>
>>> It will halt whenever it reaches final state means
>>> if and only if it reaches its final state it halts.
>>
>> Dosn't matter if you can't write a publishable proof.
>>
>> Mikko
>>
>
> The code <is> the proof.
>

WHAT code? You haven't shown any code that does the magic you claim.

You last code sample hide the magic halt detection in a function that
wasn't shown, just described as detecting the mythical halting pattern
that exists in P(P) that actually correctly detects that it doesn't
halt, even if H(P,P) return the 0 to it which causes it to halt.

Re: Halting Problem proof refutation is a tautology thus irrefutable [ new criteria ]

<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!border1.nntp.dca1.giganews.com!nntp.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 13:30:22 -0500
Date: Sun, 19 Jun 2022 13:30:22 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ new criteria ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <CNJrK.175022$JVi.9534@fx17.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 208
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-zTqDafd6A7GtonTtSAZA4HwveBSzEvoodFVFFPPzLyMd465b17bC0CBH8xXEuxyAKTeBCbN2B04pPoO!SbUTYDmDz1SwZw0DsQepFm6nRdNkVfhNV+8PRM2xzbKyelp+UhqP+roqphYXl3Vh+tPXXlFcNuOb
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: 10830
 by: olcott - Sun, 19 Jun 2022 18:30 UTC

On 6/19/2022 1:20 PM, Richard Damon wrote:
> On 6/19/22 2:08 PM, olcott wrote:
>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 12:16:05 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>
>>>>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>>>>> these actual inputs.
>>>>>>>>>>
>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>> non-halting whenever it correctly detects [in a finite number
>>>>>>>>>> of steps] that its correct and complete simulation of its
>>>>>>>>>> input would never reach [a] final state of this input then all
>>>>>>>>>> [these] inputs (including pathological inputs) are decided
>>>>>>>>>> correctly.
>>>>>>>>>
>>>>>>>>> void Px(u32 x)
>>>>>>>>> {
>>>>>>>>>        H(x, x);
>>>>>>>>>        return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>>> Input_Halts = 0
>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>
>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>> correctly. QED.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [000010fa](01)  55              push ebp
>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>>> [00001114](01)  c3              ret
>>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>>
>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
>>>>>>>> ...[000010e0][00211eca][000010da] 50         push eax      //
>>>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08     mov
>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51         push
>>>>>>>> ecx      // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
>>>>>>>> Simulation Stopped
>>>>>>>>
>>>>>>>> *All technically competent software engineers* will see that
>>>>>>>> when H bases its halt status decision on whether or not its
>>>>>>>> complete and correct x86 emulation of its input would ever reach
>>>>>>>> the "ret" instruction of this input that H is correct to reject
>>>>>>>> this input.
>>>>>>>
>>>>>>> void Px(u32 x)
>>>>>>> {
>>>>>>>       H(x, x);
>>>>>>>       return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>> }
>>>>>>>
>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>> Input_Halts = 0
>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>> Number of Instructions Executed(16120)
>>>>>>>
>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>> correctly. QED.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> *All technically competent software engineers*
>>>>> void Px(u32 x)
>>>>> {
>>>>>      H(x, x);
>>>>>      return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>> }
>>>>>
>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>> Input_Halts = 0
>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>> Number of Instructions Executed(16120)
>>>>>
>>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>>> QED.
>>>>>
>>>>> /Flibble
>>>>
>>>> Because it is an easily verified fact that the correct and complete
>>>> x86 emulation of the input to H(P,P) by H would never reach the "ret"
>>>> instruction of P and this is the criterion measure for H to reject
>>>> its input how do you figure that H gets the wrong answer?
>>>>
>>>> What I am saying is a logical tautology the same as when we know that
>>>> X is a black cat then we know that X is a cat.
>>> We are talking about Px, not P. We are talking about your H not
>>> analysing what its input actually does and instead assuming that an
>>> input that calls H is always pathological.
>>>
>>> void Px(u32 x)
>>> {
>>>     H(x, x);
>>>     return;
>>> }
>>>
>>> int main()
>>> {
>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>> }
>>>
>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>> ...[000013eb][00102353][00000000] 50              push eax
>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>> Input_Halts = 0
>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>> ...[000013fc][0010235f][00000004] c3              ret
>>> Number of Instructions Executed(16120)
>>>
>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>> QED.
>>>
>>> /Flibble
>>>
>>
>> DO YOU AGREE WITH THIS?
>> H(Px,Px) does correctly determine that the complete and correct x86
>> emulation of its input would never reach the "ret" instruction of Px.
>>
>
> That is only true if H never returns ANY answer (and thus fails to be a
> decider).
Competent software engineers will understand that when the behavior of
Px matches this pattern that correct and complete x86 emulation of the
input to H(Px,Px) by H would never reach the "ret" instruction of Px:


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable [ new criteria ]

<y7KrK.139604$X_i.4832@fx18.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ new criteria ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 232
Message-ID: <y7KrK.139604$X_i.4832@fx18.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: Sun, 19 Jun 2022 14:43:41 -0400
X-Received-Bytes: 11776
 by: Richard Damon - Sun, 19 Jun 2022 18:43 UTC

On 6/19/22 2:30 PM, olcott wrote:
> On 6/19/2022 1:20 PM, Richard Damon wrote:
>> On 6/19/22 2:08 PM, olcott wrote:
>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>>>> On Sun, 19 Jun 2022 12:16:05 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>
>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>>
>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>>>>>> these actual inputs.
>>>>>>>>>>>
>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>> non-halting whenever it correctly detects [in a finite number
>>>>>>>>>>> of steps] that its correct and complete simulation of its
>>>>>>>>>>> input would never reach [a] final state of this input then all
>>>>>>>>>>> [these] inputs (including pathological inputs) are decided
>>>>>>>>>>> correctly.
>>>>>>>>>>
>>>>>>>>>> void Px(u32 x)
>>>>>>>>>> {
>>>>>>>>>>        H(x, x);
>>>>>>>>>>        return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>>>> Input_Halts = 0
>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>
>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>> correctly. QED.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [000010fa](01)  55              push ebp
>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>>>> [00001114](01)  c3              ret
>>>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>>>
>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
>>>>>>>>> ...[000010e0][00211eca][000010da] 50         push eax      //
>>>>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08     mov
>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51         push
>>>>>>>>> ecx      // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
>>>>>>>>> Simulation Stopped
>>>>>>>>>
>>>>>>>>> *All technically competent software engineers* will see that
>>>>>>>>> when H bases its halt status decision on whether or not its
>>>>>>>>> complete and correct x86 emulation of its input would ever reach
>>>>>>>>> the "ret" instruction of this input that H is correct to reject
>>>>>>>>> this input.
>>>>>>>>
>>>>>>>> void Px(u32 x)
>>>>>>>> {
>>>>>>>>       H(x, x);
>>>>>>>>       return;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>> }
>>>>>>>>
>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>> Input_Halts = 0
>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>
>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>> correctly. QED.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> *All technically competent software engineers*
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>>      H(x, x);
>>>>>>      return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>> }
>>>>>>
>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>> Input_Halts = 0
>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>> Number of Instructions Executed(16120)
>>>>>>
>>>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>>>> QED.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> Because it is an easily verified fact that the correct and complete
>>>>> x86 emulation of the input to H(P,P) by H would never reach the "ret"
>>>>> instruction of P and this is the criterion measure for H to reject
>>>>> its input how do you figure that H gets the wrong answer?
>>>>>
>>>>> What I am saying is a logical tautology the same as when we know that
>>>>> X is a black cat then we know that X is a cat.
>>>> We are talking about Px, not P. We are talking about your H not
>>>> analysing what its input actually does and instead assuming that an
>>>> input that calls H is always pathological.
>>>>
>>>> void Px(u32 x)
>>>> {
>>>>     H(x, x);
>>>>     return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>> }
>>>>
>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>> Input_Halts = 0
>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>> Number of Instructions Executed(16120)
>>>>
>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>> QED.
>>>>
>>>> /Flibble
>>>>
>>>
>>> DO YOU AGREE WITH THIS?
>>> H(Px,Px) does correctly determine that the complete and correct x86
>>> emulation of its input would never reach the "ret" instruction of Px.
>>>
>>
>> That is only true if H never returns ANY answer (and thus fails to be
>> a decider).
> Competent software engineers will understand that when the behavior of
> Px matches this pattern that correct and complete x86 emulation of the
> input to H(Px,Px) by H would never reach the "ret" instruction of Px:
>
> H knows its own machine address and on this basis:
> (a) H recognizes that Px is calling H with the same arguments that H was
> called with.
> (b) There are no instructions in Px that could possibly escape this
> infinitely recursive emulation.
> (c) H aborts its emulation of Px before Px its call to H is invoked.
>
>


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman ]

<GPednbS5wMDL6zL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 14:17:42 -0500
Date: Sun, 19 Jun 2022 14:17:42 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ strawman ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
<y7KrK.139604$X_i.4832@fx18.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <y7KrK.139604$X_i.4832@fx18.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <GPednbS5wMDL6zL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 230
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-o8WNLU5E9IvrPopS8TGNsJqVVeI4kdpFswmvq9l42X2e6/bxOcUDlCsZmYMzbHW2lYFhsjnymVerzdu!modWQtLPqdOxpmCSuEy8WgGw4OG3ghPxbvlUdpO7B4UFyp1lv6sZJ9Eynoo240IrTmUxpkvJ8LXy
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: 12229
 by: olcott - Sun, 19 Jun 2022 19:17 UTC

On 6/19/2022 1:43 PM, Richard Damon wrote:
> On 6/19/22 2:30 PM, olcott wrote:
>> On 6/19/2022 1:20 PM, Richard Damon wrote:
>>> On 6/19/22 2:08 PM, olcott wrote:
>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>>>>>>> these actual inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite number
>>>>>>>>>>>> of steps] that its correct and complete simulation of its
>>>>>>>>>>>> input would never reach [a] final state of this input then all
>>>>>>>>>>>> [these] inputs (including pathological inputs) are decided
>>>>>>>>>>>> correctly.
>>>>>>>>>>>
>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>        H(x, x);
>>>>>>>>>>>        return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>>
>>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>>> correctly. QED.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [000010fa](01)  55              push ebp
>>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>>>>> [00001114](01)  c3              ret
>>>>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>>>>
>>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> ...[000010e0][00211eca][000010da] 50         push eax      //
>>>>>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08     mov
>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51         push
>>>>>>>>>> ecx      // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
>>>>>>>>>> Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> *All technically competent software engineers* will see that
>>>>>>>>>> when H bases its halt status decision on whether or not its
>>>>>>>>>> complete and correct x86 emulation of its input would ever reach
>>>>>>>>>> the "ret" instruction of this input that H is correct to reject
>>>>>>>>>> this input.
>>>>>>>>>
>>>>>>>>> void Px(u32 x)
>>>>>>>>> {
>>>>>>>>>       H(x, x);
>>>>>>>>>       return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>>> Input_Halts = 0
>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>
>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>> correctly. QED.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> *All technically competent software engineers*
>>>>>>> void Px(u32 x)
>>>>>>> {
>>>>>>>      H(x, x);
>>>>>>>      return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>> }
>>>>>>>
>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>> Input_Halts = 0
>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>> Number of Instructions Executed(16120)
>>>>>>>
>>>>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>>>>> QED.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Because it is an easily verified fact that the correct and complete
>>>>>> x86 emulation of the input to H(P,P) by H would never reach the "ret"
>>>>>> instruction of P and this is the criterion measure for H to reject
>>>>>> its input how do you figure that H gets the wrong answer?
>>>>>>
>>>>>> What I am saying is a logical tautology the same as when we know that
>>>>>> X is a black cat then we know that X is a cat.
>>>>> We are talking about Px, not P. We are talking about your H not
>>>>> analysing what its input actually does and instead assuming that an
>>>>> input that calls H is always pathological.
>>>>>
>>>>> void Px(u32 x)
>>>>> {
>>>>>     H(x, x);
>>>>>     return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>> }
>>>>>
>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>> Input_Halts = 0
>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>> Number of Instructions Executed(16120)
>>>>>
>>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>>> QED.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> DO YOU AGREE WITH THIS?
>>>> H(Px,Px) does correctly determine that the complete and correct x86
>>>> emulation of its input would never reach the "ret" instruction of Px.
>>>>
>>>
>>> That is only true if H never returns ANY answer (and thus fails to be
>>> a decider).
>> Competent software engineers will understand that when the behavior of
>> Px matches this pattern that correct and complete x86 emulation of the
>> input to H(Px,Px) by H would never reach the "ret" instruction of Px:
>>
>> H knows its own machine address and on this basis:
>> (a) H recognizes that Px is calling H with the same arguments that H
>> was called with.
>> (b) There are no instructions in Px that could possibly escape this
>> infinitely recursive emulation.
>> (c) H aborts its emulation of Px before Px its call to H is invoked.
>>
>>
>
> Only if H never aborts. If H does abort, then Px(Px), whose behavior
> exactly matches the CORRECT emulation of the input to H(Px,Px) BY
> DEFINITION shows this.


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman 2 ]

<UOudnf9XgJ0F6jL_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!buffer1.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 14:23:04 -0500
Date: Sun, 19 Jun 2022 14:23:04 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ strawman 2 ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
<y7KrK.139604$X_i.4832@fx18.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <y7KrK.139604$X_i.4832@fx18.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <UOudnf9XgJ0F6jL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 235
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Jnj2DKTry43TpcWom3R3c//wTx5344720/EQAXSL8ukA0hStEw9QlQJ6bYMBcccpmRO1vI2Ix5eoF7b!BQ77jCcS4Q6nXygfKeCplY0mpm8mZs4gmjNfj5+um5sM+i71ES5rlo2cHBBHSCi80iDdlA1yL6KN
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: 12355
 by: olcott - Sun, 19 Jun 2022 19:23 UTC

On 6/19/2022 1:43 PM, Richard Damon wrote:
> On 6/19/22 2:30 PM, olcott wrote:
>> On 6/19/2022 1:20 PM, Richard Damon wrote:
>>> On 6/19/22 2:08 PM, olcott wrote:
>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> computation that halts … the Turing machine will halt whenever
>>>>>>>>>>>> it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>
>>>>>>>>>>>> A halt decider must compute the mapping from its inputs to an
>>>>>>>>>>>> accept or reject state on the basis of the actual behavior of
>>>>>>>>>>>> these actual inputs.
>>>>>>>>>>>>
>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite number
>>>>>>>>>>>> of steps] that its correct and complete simulation of its
>>>>>>>>>>>> input would never reach [a] final state of this input then all
>>>>>>>>>>>> [these] inputs (including pathological inputs) are decided
>>>>>>>>>>>> correctly.
>>>>>>>>>>>
>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>        H(x, x);
>>>>>>>>>>>        return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>>>
>>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>>> correctly. QED.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [000010fa](01)  55              push ebp
>>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>>>>> [00001114](01)  c3              ret
>>>>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>>>>
>>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov eax,[ebp+08]
>>>>>>>>>> ...[000010e0][00211eca][000010da] 50         push eax      //
>>>>>>>>>> push P ...[000010e1][00211eca][000010da] 8b4d08     mov
>>>>>>>>>> ecx,[ebp+08] ...[000010e4][00211ec6][000010da] 51         push
>>>>>>>>>> ecx      // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation Detected
>>>>>>>>>> Simulation Stopped
>>>>>>>>>>
>>>>>>>>>> *All technically competent software engineers* will see that
>>>>>>>>>> when H bases its halt status decision on whether or not its
>>>>>>>>>> complete and correct x86 emulation of its input would ever reach
>>>>>>>>>> the "ret" instruction of this input that H is correct to reject
>>>>>>>>>> this input.
>>>>>>>>>
>>>>>>>>> void Px(u32 x)
>>>>>>>>> {
>>>>>>>>>       H(x, x);
>>>>>>>>>       return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>>>> Input_Halts = 0
>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>
>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>> correctly. QED.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> *All technically competent software engineers*
>>>>>>> void Px(u32 x)
>>>>>>> {
>>>>>>>      H(x, x);
>>>>>>>      return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>> }
>>>>>>>
>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>> Input_Halts = 0
>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>> Number of Instructions Executed(16120)
>>>>>>>
>>>>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>>>>> QED.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Because it is an easily verified fact that the correct and complete
>>>>>> x86 emulation of the input to H(P,P) by H would never reach the "ret"
>>>>>> instruction of P and this is the criterion measure for H to reject
>>>>>> its input how do you figure that H gets the wrong answer?
>>>>>>
>>>>>> What I am saying is a logical tautology the same as when we know that
>>>>>> X is a black cat then we know that X is a cat.
>>>>> We are talking about Px, not P. We are talking about your H not
>>>>> analysing what its input actually does and instead assuming that an
>>>>> input that calls H is always pathological.
>>>>>
>>>>> void Px(u32 x)
>>>>> {
>>>>>     H(x, x);
>>>>>     return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>> }
>>>>>
>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>> Input_Halts = 0
>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>> Number of Instructions Executed(16120)
>>>>>
>>>>> It gets the answer wrong, i.e. input has not been decided correctly.
>>>>> QED.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> DO YOU AGREE WITH THIS?
>>>> H(Px,Px) does correctly determine that the complete and correct x86
>>>> emulation of its input would never reach the "ret" instruction of Px.
>>>>
>>>
>>> That is only true if H never returns ANY answer (and thus fails to be
>>> a decider).
>> Competent software engineers will understand that when the behavior of
>> Px matches this pattern that correct and complete x86 emulation of the
>> input to H(Px,Px) by H would never reach the "ret" instruction of Px:
>>
>> H knows its own machine address and on this basis:
>> (a) H recognizes that Px is calling H with the same arguments that H
>> was called with.
>> (b) There are no instructions in Px that could possibly escape this
>> infinitely recursive emulation.
>> (c) H aborts its emulation of Px before Px its call to H is invoked.
>>
>>
>
> Only if H never aborts. If H does abort, then Px(Px), whose behavior
> exactly matches the CORRECT emulation of the input to H(Px,Px) BY
> DEFINITION shows this.


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman ]

<20220619205952.00005846@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx09.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus
irrefutable [ strawman ]
Message-ID: <20220619205952.00005846@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
<y7KrK.139604$X_i.4832@fx18.iad>
<GPednbS5wMDL6zL_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 287
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 19:59:52 UTC
Date: Sun, 19 Jun 2022 20:59:52 +0100
X-Received-Bytes: 14282
 by: Mr Flibble - Sun, 19 Jun 2022 19:59 UTC

On Sun, 19 Jun 2022 14:17:42 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 1:43 PM, Richard Damon wrote:
> > On 6/19/22 2:30 PM, olcott wrote:
> >> On 6/19/2022 1:20 PM, Richard Damon wrote:
> >>> On 6/19/22 2:08 PM, olcott wrote:
> >>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 12:16:05 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> computation that halts … the Turing machine will halt
> >>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
> >>>>>>>>>>>>
> >>>>>>>>>>>> A halt decider must compute the mapping from its inputs
> >>>>>>>>>>>> to an accept or reject state on the basis of the actual
> >>>>>>>>>>>> behavior of these actual inputs.
> >>>>>>>>>>>>
> >>>>>>>>>>>> When a simulating halt decider rejects all inputs as
> >>>>>>>>>>>> non-halting whenever it correctly detects [in a finite
> >>>>>>>>>>>> number of steps] that its correct and complete
> >>>>>>>>>>>> simulation of its input would never reach [a] final
> >>>>>>>>>>>> state of this input then all [these] inputs (including
> >>>>>>>>>>>> pathological inputs) are decided correctly.
> >>>>>>>>>>>
> >>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>> {
> >>>>>>>>>>>        H(x, x);
> >>>>>>>>>>>        return;
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
> >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
> >>>>>>>>>>> e880f0ffff      call 00000476 Input_Halts = 0
> >>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
> >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>>>     pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>>>>     ret Number of Instructions Executed(16120)
> >>>>>>>>>>>
> >>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>>>>>> correctly. QED.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>> _P()
> >>>>>>>>>> [000010fa](01)  55              push ebp
> >>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
> >>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
> >>>>>>>>>> [00001100](01)  50              push eax       // push P
> >>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
> >>>>>>>>>> [00001104](01)  51              push ecx       // push P
> >>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
> >>>>>>>>>> [0000110a](03)  83c408          add esp,+08
> >>>>>>>>>> [0000110d](02)  85c0            test eax,eax
> >>>>>>>>>> [0000110f](02)  7402            jz 00001113
> >>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
> >>>>>>>>>> [00001113](01)  5d              pop ebp
> >>>>>>>>>> [00001114](01)  c3              ret
> >>>>>>>>>> Size in bytes:(0027) [00001114]
> >>>>>>>>>>
> >>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
> >>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
> >>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
> >>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov
> >>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
> >>>>>>>>>> push eax      // push P ...[000010e1][00211eca][000010da]
> >>>>>>>>>> 8b4d08     mov ecx,[ebp+08]
> >>>>>>>>>> ...[000010e4][00211ec6][000010da] 51         push ecx
> >>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff
> >>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation
> >>>>>>>>>> Detected Simulation Stopped
> >>>>>>>>>>
> >>>>>>>>>> *All technically competent software engineers* will see
> >>>>>>>>>> that when H bases its halt status decision on whether or
> >>>>>>>>>> not its complete and correct x86 emulation of its input
> >>>>>>>>>> would ever reach the "ret" instruction of this input that
> >>>>>>>>>> H is correct to reject this input.
> >>>>>>>>>
> >>>>>>>>> void Px(u32 x)
> >>>>>>>>> {
> >>>>>>>>>       H(x, x);
> >>>>>>>>>       return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
> >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>>>>     call 00000476 Input_Halts = 0
> >>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
> >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>   pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>> ret Number of Instructions Executed(16120)
> >>>>>>>>>
> >>>>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>>>> correctly. QED.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> *All technically competent software engineers*
> >>>>>>> void Px(u32 x)
> >>>>>>> {
> >>>>>>>      H(x, x);
> >>>>>>>      return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>> }
> >>>>>>>
> >>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
> >>>>>>> ...[000013eb][00102353][00000000] 50              push eax
> >>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push
> >>>>>>> 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>> call 00000476 Input_Halts = 0
> >>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
> >>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
> >>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
> >>>>>>> ...[000013fc][0010235f][00000004] c3              ret
> >>>>>>> Number of Instructions Executed(16120)
> >>>>>>>
> >>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>> correctly. QED.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>
> >>>>>> Because it is an easily verified fact that the correct and
> >>>>>> complete x86 emulation of the input to H(P,P) by H would never
> >>>>>> reach the "ret" instruction of P and this is the criterion
> >>>>>> measure for H to reject its input how do you figure that H
> >>>>>> gets the wrong answer?
> >>>>>>
> >>>>>> What I am saying is a logical tautology the same as when we
> >>>>>> know that X is a black cat then we know that X is a cat.
> >>>>> We are talking about Px, not P. We are talking about your H not
> >>>>> analysing what its input actually does and instead assuming
> >>>>> that an input that calls H is always pathological.
> >>>>>
> >>>>> void Px(u32 x)
> >>>>> {
> >>>>>     H(x, x);
> >>>>>     return;
> >>>>> }
> >>>>>
> >>>>> int main()
> >>>>> {
> >>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>> }
> >>>>>
> >>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
> >>>>> ...[000013eb][00102353][00000000] 50              push eax
> >>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
> >>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
> >>>>> Input_Halts = 0
> >>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
> >>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
> >>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
> >>>>> ...[000013fc][0010235f][00000004] c3              ret
> >>>>> Number of Instructions Executed(16120)
> >>>>>
> >>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>> correctly. QED.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> DO YOU AGREE WITH THIS?
> >>>> H(Px,Px) does correctly determine that the complete and correct
> >>>> x86 emulation of its input would never reach the "ret"
> >>>> instruction of Px.
> >>>
> >>> That is only true if H never returns ANY answer (and thus fails
> >>> to be a decider).
> >> Competent software engineers will understand that when the
> >> behavior of Px matches this pattern that correct and complete x86
> >> emulation of the input to H(Px,Px) by H would never reach the
> >> "ret" instruction of Px:
> >>
> >> H knows its own machine address and on this basis:
> >> (a) H recognizes that Px is calling H with the same arguments that
> >> H was called with.
> >> (b) There are no instructions in Px that could possibly escape
> >> this infinitely recursive emulation.
> >> (c) H aborts its emulation of Px before Px its call to H is
> >> invoked.
> >>
> >>
> >
> > Only if H never aborts. If H does abort, then Px(Px), whose
> > behavior exactly matches the CORRECT emulation of the input to
> > H(Px,Px) BY DEFINITION shows this.
>
> The question is: Would (future tense) the complete and correct x86
> emulation of the input to H(Px,Px) by H ever reach the "ret"
> instruction of Px.
>
> You always change this question to a different question:
>
> Does (present tense) the complete and correct x86 emulation of the
> input to H(Px,Px) by H ever reach the "ret" instruction of Px.


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman ]

<5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sun, 19 Jun 2022 15:05:11 -0500
Date: Sun, 19 Jun 2022 15:05:11 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.10.0
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ strawman ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
<y7KrK.139604$X_i.4832@fx18.iad>
<GPednbS5wMDL6zL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619205952.00005846@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619205952.00005846@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 250
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-47pDw314XUMZIxF+zE81YNjxweIHC83sJebh3zDHgn7r8JczS5ZCLU3BbBIIJ3iaw05Nl7ZAcuqlHPn!CXe5iC/CGSfa2ug171TFU6FJ+hE53kTAJGCn77wIcBSaU8V6E9RbZnxxyV34sZ0xDfBUyRCgr68L
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: 13006
 by: olcott - Sun, 19 Jun 2022 20:05 UTC

On 6/19/2022 2:59 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 14:17:42 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 1:43 PM, Richard Damon wrote:
>>> On 6/19/22 2:30 PM, olcott wrote:
>>>> On 6/19/2022 1:20 PM, Richard Damon wrote:
>>>>> On 6/19/22 2:08 PM, olcott wrote:
>>>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> computation that halts … the Turing machine will halt
>>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs
>>>>>>>>>>>>>> to an accept or reject state on the basis of the actual
>>>>>>>>>>>>>> behavior of these actual inputs.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
>>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite
>>>>>>>>>>>>>> number of steps] that its correct and complete
>>>>>>>>>>>>>> simulation of its input would never reach [a] final
>>>>>>>>>>>>>> state of this input then all [these] inputs (including
>>>>>>>>>>>>>> pathological inputs) are decided correctly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>        H(x, x);
>>>>>>>>>>>>>        return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
>>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
>>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
>>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
>>>>>>>>>>>>> e880f0ffff      call 00000476 Input_Halts = 0
>>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
>>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
>>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
>>>>>>>>>>>>>     pop ebp ...[000013fc][0010235f][00000004] c3
>>>>>>>>>>>>>     ret Number of Instructions Executed(16120)
>>>>>>>>>>>>>
>>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>>>>> correctly. QED.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [000010fa](01)  55              push ebp
>>>>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
>>>>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
>>>>>>>>>>>> [00001100](01)  50              push eax       // push P
>>>>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
>>>>>>>>>>>> [00001104](01)  51              push ecx       // push P
>>>>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
>>>>>>>>>>>> [0000110a](03)  83c408          add esp,+08
>>>>>>>>>>>> [0000110d](02)  85c0            test eax,eax
>>>>>>>>>>>> [0000110f](02)  7402            jz 00001113
>>>>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
>>>>>>>>>>>> [00001113](01)  5d              pop ebp
>>>>>>>>>>>> [00001114](01)  c3              ret
>>>>>>>>>>>> Size in bytes:(0027) [00001114]
>>>>>>>>>>>>
>>>>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
>>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
>>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
>>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov
>>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
>>>>>>>>>>>> push eax      // push P ...[000010e1][00211eca][000010da]
>>>>>>>>>>>> 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>> ...[000010e4][00211ec6][000010da] 51         push ecx
>>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff
>>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation
>>>>>>>>>>>> Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> *All technically competent software engineers* will see
>>>>>>>>>>>> that when H bases its halt status decision on whether or
>>>>>>>>>>>> not its complete and correct x86 emulation of its input
>>>>>>>>>>>> would ever reach the "ret" instruction of this input that
>>>>>>>>>>>> H is correct to reject this input.
>>>>>>>>>>>
>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>       H(x, x);
>>>>>>>>>>>       return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
>>>>>>>>>>>     call 00000476 Input_Halts = 0
>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
>>>>>>>>>>>   pop ebp ...[000013fc][0010235f][00000004] c3
>>>>>>>>>>> ret Number of Instructions Executed(16120)
>>>>>>>>>>>
>>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>>>> correctly. QED.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> *All technically competent software engineers*
>>>>>>>>> void Px(u32 x)
>>>>>>>>> {
>>>>>>>>>      H(x, x);
>>>>>>>>>      return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push
>>>>>>>>> 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
>>>>>>>>> call 00000476 Input_Halts = 0
>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>>>> Number of Instructions Executed(16120)
>>>>>>>>>
>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>>>> correctly. QED.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Because it is an easily verified fact that the correct and
>>>>>>>> complete x86 emulation of the input to H(P,P) by H would never
>>>>>>>> reach the "ret" instruction of P and this is the criterion
>>>>>>>> measure for H to reject its input how do you figure that H
>>>>>>>> gets the wrong answer?
>>>>>>>>
>>>>>>>> What I am saying is a logical tautology the same as when we
>>>>>>>> know that X is a black cat then we know that X is a cat.
>>>>>>> We are talking about Px, not P. We are talking about your H not
>>>>>>> analysing what its input actually does and instead assuming
>>>>>>> that an input that calls H is always pathological.
>>>>>>>
>>>>>>> void Px(u32 x)
>>>>>>> {
>>>>>>>     H(x, x);
>>>>>>>     return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
>>>>>>> }
>>>>>>>
>>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013eb][00102353][00000000] 50              push eax
>>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push 00000427
>>>>>>> ---[000013f1][0010234f][00000427] e880f0ffff      call 00000476
>>>>>>> Input_Halts = 0
>>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
>>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
>>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
>>>>>>> ...[000013fc][0010235f][00000004] c3              ret
>>>>>>> Number of Instructions Executed(16120)
>>>>>>>
>>>>>>> It gets the answer wrong, i.e. input has not been decided
>>>>>>> correctly. QED.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> DO YOU AGREE WITH THIS?
>>>>>> H(Px,Px) does correctly determine that the complete and correct
>>>>>> x86 emulation of its input would never reach the "ret"
>>>>>> instruction of Px.
>>>>>
>>>>> That is only true if H never returns ANY answer (and thus fails
>>>>> to be a decider).
>>>> Competent software engineers will understand that when the
>>>> behavior of Px matches this pattern that correct and complete x86
>>>> emulation of the input to H(Px,Px) by H would never reach the
>>>> "ret" instruction of Px:
>>>>
>>>> H knows its own machine address and on this basis:
>>>> (a) H recognizes that Px is calling H with the same arguments that
>>>> H was called with.
>>>> (b) There are no instructions in Px that could possibly escape
>>>> this infinitely recursive emulation.
>>>> (c) H aborts its emulation of Px before Px its call to H is
>>>> invoked.
>>>>
>>>>
>>>
>>> Only if H never aborts. If H does abort, then Px(Px), whose
>>> behavior exactly matches the CORRECT emulation of the input to
>>> H(Px,Px) BY DEFINITION shows this.
>>
>> The question is: Would (future tense) the complete and correct x86
>> emulation of the input to H(Px,Px) by H ever reach the "ret"
>> instruction of Px.
>>
>> You always change this question to a different question:
>>
>> Does (present tense) the complete and correct x86 emulation of the
>> input to H(Px,Px) by H ever reach the "ret" instruction of Px.
>
> The complete and correct x86 emulation of the input to H(Px, Px) should
> be to allow Px to halt, which is what Px is defined to do:


Click here to read the complete article
Re: Halting Problem proof refutation is a tautology thus irrefutable [ strawman ]

<20220619210812.00003001@reddwarf.jmc>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
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!news.highwinds-media.com!fx02.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc (Mr Flibble)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus
irrefutable [ strawman ]
Message-ID: <20220619210812.00003001@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619162307.000041b2@reddwarf.jmc>
<--edndX8966r3jL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619170111.00002570@reddwarf.jmc>
<JfadnQoBhqnh0DL_nZ2dnUU7_8xh4p2d@giganews.com>
<20220619180139.000016fd@reddwarf.jmc>
<1aGdnUFFEoFIxDL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619184006.00002392@reddwarf.jmc>
<lpudnfhnnOCe-zL_nZ2dnUU7_8xh4p2d@giganews.com>
<CNJrK.175022$JVi.9534@fx17.iad>
<CqOdnWr5A4-j9jL_nZ2dnUU7_83NnZ2d@giganews.com>
<y7KrK.139604$X_i.4832@fx18.iad>
<GPednbS5wMDL6zL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619205952.00005846@reddwarf.jmc>
<5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>
Organization: Jupiter Mining Corp
X-Newsreader: Claws Mail 3.17.8 (GTK+ 2.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Lines: 293
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 20:08:12 UTC
Date: Sun, 19 Jun 2022 21:08:12 +0100
X-Received-Bytes: 14756
 by: Mr Flibble - Sun, 19 Jun 2022 20:08 UTC

On Sun, 19 Jun 2022 15:05:11 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 2:59 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 14:17:42 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 1:43 PM, Richard Damon wrote:
> >>> On 6/19/22 2:30 PM, olcott wrote:
> >>>> On 6/19/2022 1:20 PM, Richard Damon wrote:
> >>>>> On 6/19/22 2:08 PM, olcott wrote:
> >>>>>> On 6/19/2022 12:40 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 12:16:05 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 12:01 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 11:23:24 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>> On 6/19/2022 11:01 AM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 19 Jun 2022 10:39:34 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>> On 6/19/2022 10:23 AM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 19 Jun 2022 10:13:00 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>> computation that halts … the Turing machine will halt
> >>>>>>>>>>>>>> whenever it enters a final state. (Linz:1990:234)
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> A halt decider must compute the mapping from its inputs
> >>>>>>>>>>>>>> to an accept or reject state on the basis of the actual
> >>>>>>>>>>>>>> behavior of these actual inputs.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> When a simulating halt decider rejects all inputs as
> >>>>>>>>>>>>>> non-halting whenever it correctly detects [in a finite
> >>>>>>>>>>>>>> number of steps] that its correct and complete
> >>>>>>>>>>>>>> simulation of its input would never reach [a] final
> >>>>>>>>>>>>>> state of this input then all [these] inputs (including
> >>>>>>>>>>>>>> pathological inputs) are decided correctly.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>>        H(x, x);
> >>>>>>>>>>>>>        return;
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> int main()
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>>        Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
> >>>>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427]
> >>>>>>>>>>>>> e880f0ffff      call 00000476 Input_Halts = 0
> >>>>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
> >>>>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>>>>>     pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>>>>>>     ret Number of Instructions Executed(16120)
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> It gets the answer wrong, i.e. input has not been
> >>>>>>>>>>>>> decided correctly. QED.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> _P()
> >>>>>>>>>>>> [000010fa](01)  55              push ebp
> >>>>>>>>>>>> [000010fb](02)  8bec            mov ebp,esp
> >>>>>>>>>>>> [000010fd](03)  8b4508          mov eax,[ebp+08]
> >>>>>>>>>>>> [00001100](01)  50              push eax       // push P
> >>>>>>>>>>>> [00001101](03)  8b4d08          mov ecx,[ebp+08]
> >>>>>>>>>>>> [00001104](01)  51              push ecx       // push P
> >>>>>>>>>>>> [00001105](05)  e800feffff      call 00000f0a  // call H
> >>>>>>>>>>>> [0000110a](03)  83c408          add esp,+08
> >>>>>>>>>>>> [0000110d](02)  85c0            test eax,eax
> >>>>>>>>>>>> [0000110f](02)  7402            jz 00001113
> >>>>>>>>>>>> [00001111](02)  ebfe            jmp 00001111
> >>>>>>>>>>>> [00001113](01)  5d              pop ebp
> >>>>>>>>>>>> [00001114](01)  c3              ret
> >>>>>>>>>>>> Size in bytes:(0027) [00001114]
> >>>>>>>>>>>>
> >>>>>>>>>>>> Begin Simulation   Execution Trace Stored at:211ee2
> >>>>>>>>>>>> ...[000010da][00211ece][00211ed2] 55         push ebp
> >>>>>>>>>>>> ...[000010db][00211ece][00211ed2] 8bec       mov ebp,esp
> >>>>>>>>>>>> ...[000010dd][00211ece][00211ed2] 8b4508     mov
> >>>>>>>>>>>> eax,[ebp+08] ...[000010e0][00211eca][000010da] 50
> >>>>>>>>>>>> push eax      // push P ...[000010e1][00211eca][000010da]
> >>>>>>>>>>>> 8b4d08     mov ecx,[ebp+08]
> >>>>>>>>>>>> ...[000010e4][00211ec6][000010da] 51         push ecx
> >>>>>>>>>>>> // push P ...[000010e5][00211ec2][000010ea] e820feffff
> >>>>>>>>>>>> call 00000f0a // call H Infinitely Recursive Simulation
> >>>>>>>>>>>> Detected Simulation Stopped
> >>>>>>>>>>>>
> >>>>>>>>>>>> *All technically competent software engineers* will see
> >>>>>>>>>>>> that when H bases its halt status decision on whether or
> >>>>>>>>>>>> not its complete and correct x86 emulation of its input
> >>>>>>>>>>>> would ever reach the "ret" instruction of this input that
> >>>>>>>>>>>> H is correct to reject this input.
> >>>>>>>>>>>
> >>>>>>>>>>> void Px(u32 x)
> >>>>>>>>>>> {
> >>>>>>>>>>>       H(x, x);
> >>>>>>>>>>>       return;
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>>       Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
> >>>>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>>>>>>     call 00000476 Input_Halts = 0
> >>>>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
> >>>>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>>>   pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>>>> ret Number of Instructions Executed(16120)
> >>>>>>>>>>>
> >>>>>>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>>>>>> correctly. QED.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>> *All technically competent software engineers*
> >>>>>>>>> void Px(u32 x)
> >>>>>>>>> {
> >>>>>>>>>      H(x, x);
> >>>>>>>>>      return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>>      Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> ...[000013e8][00102357][00000000] 83c408          add
> >>>>>>>>> esp,+08 ...[000013eb][00102353][00000000] 50
> >>>>>>>>> push eax ...[000013ec][0010234f][00000427] 6827040000
> >>>>>>>>> push 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>>>> call 00000476 Input_Halts = 0
> >>>>>>>>> ...[000013f6][00102357][00000000] 83c408          add
> >>>>>>>>> esp,+08 ...[000013f9][00102357][00000000] 33c0
> >>>>>>>>> xor eax,eax ...[000013fb][0010235b][00100000] 5d
> >>>>>>>>>   pop ebp ...[000013fc][0010235f][00000004] c3
> >>>>>>>>> ret Number of Instructions Executed(16120)
> >>>>>>>>>
> >>>>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>>>> correctly. QED.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> Because it is an easily verified fact that the correct and
> >>>>>>>> complete x86 emulation of the input to H(P,P) by H would
> >>>>>>>> never reach the "ret" instruction of P and this is the
> >>>>>>>> criterion measure for H to reject its input how do you
> >>>>>>>> figure that H gets the wrong answer?
> >>>>>>>>
> >>>>>>>> What I am saying is a logical tautology the same as when we
> >>>>>>>> know that X is a black cat then we know that X is a cat.
> >>>>>>> We are talking about Px, not P. We are talking about your H
> >>>>>>> not analysing what its input actually does and instead
> >>>>>>> assuming that an input that calls H is always pathological.
> >>>>>>>
> >>>>>>> void Px(u32 x)
> >>>>>>> {
> >>>>>>>     H(x, x);
> >>>>>>>     return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>>     Output("Input_Halts = ", H((u32)Px, (u32)Px));
> >>>>>>> }
> >>>>>>>
> >>>>>>> ...[000013e8][00102357][00000000] 83c408          add esp,+08
> >>>>>>> ...[000013eb][00102353][00000000] 50              push eax
> >>>>>>> ...[000013ec][0010234f][00000427] 6827040000      push
> >>>>>>> 00000427 ---[000013f1][0010234f][00000427] e880f0ffff
> >>>>>>> call 00000476 Input_Halts = 0
> >>>>>>> ...[000013f6][00102357][00000000] 83c408          add esp,+08
> >>>>>>> ...[000013f9][00102357][00000000] 33c0            xor eax,eax
> >>>>>>> ...[000013fb][0010235b][00100000] 5d              pop ebp
> >>>>>>> ...[000013fc][0010235f][00000004] c3              ret
> >>>>>>> Number of Instructions Executed(16120)
> >>>>>>>
> >>>>>>> It gets the answer wrong, i.e. input has not been decided
> >>>>>>> correctly. QED.
> >>>>>>>
> >>>>>>> /Flibble
> >>>>>>>
> >>>>>>
> >>>>>> DO YOU AGREE WITH THIS?
> >>>>>> H(Px,Px) does correctly determine that the complete and correct
> >>>>>> x86 emulation of its input would never reach the "ret"
> >>>>>> instruction of Px.
> >>>>>
> >>>>> That is only true if H never returns ANY answer (and thus fails
> >>>>> to be a decider).
> >>>> Competent software engineers will understand that when the
> >>>> behavior of Px matches this pattern that correct and complete x86
> >>>> emulation of the input to H(Px,Px) by H would never reach the
> >>>> "ret" instruction of Px:
> >>>>
> >>>> H knows its own machine address and on this basis:
> >>>> (a) H recognizes that Px is calling H with the same arguments
> >>>> that H was called with.
> >>>> (b) There are no instructions in Px that could possibly escape
> >>>> this infinitely recursive emulation.
> >>>> (c) H aborts its emulation of Px before Px its call to H is
> >>>> invoked.
> >>>>
> >>>>
> >>>
> >>> Only if H never aborts. If H does abort, then Px(Px), whose
> >>> behavior exactly matches the CORRECT emulation of the input to
> >>> H(Px,Px) BY DEFINITION shows this.
> >>
> >> The question is: Would (future tense) the complete and correct x86
> >> emulation of the input to H(Px,Px) by H ever reach the "ret"
> >> instruction of Px.
> >>
> >> You always change this question to a different question:
> >>
> >> Does (present tense) the complete and correct x86 emulation of the
> >> input to H(Px,Px) by H ever reach the "ret" instruction of Px.
> >
> > The complete and correct x86 emulation of the input to H(Px, Px)
> > should be to allow Px to halt, which is what Px is defined to do:
>
> You are doing the same thing Richard is doing, getting at least one
> word of what I am saying incorrectly and then rebutting the incorrect
> paraphrase. This is the strawman error.
>
> The complete and correct x86 emulation of the input to H(Px, Px)
> BY H
> BY H
> BY H
> BY H
> BY H
>
> cannot possibly contradict the easily verified fact that Px would
> never reach its "ret" instruction. This seems to be beyond your
> ordinary software engineering technical competence.

Click here to read the complete article

Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor