Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

snafu = Situation Normal All F%$*ed up

devel / comp.theory / Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

SubjectAuthor
* Halting Problem proof refutation is a tautology thus irrefutableolcott
+* Halting Problem proof refutation is a tautology thusMr Flibble
|`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| +* Halting Problem proof refutation is a tautology thusMr Flibble
| |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| | +- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| | `* Halting Problem proof refutation is a tautology thus irrefutableMr Flibble
| |  `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |   +- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |   `* Halting Problem proof refutation is a tautology thusMr Flibble
| |    `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |     `* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |      `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |       `* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        +* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |+* Halting Problem proof refutation is a tautology thusMr Flibble
| |        ||`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || +* Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || | `* Halting Problem proof refutation is a tautology thus irrefutable [ strawman ]Mr Flibble
| |        || |  `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   +* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | +* Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | | +- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | | `* Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |  `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |   `* Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |    +* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |    |`- Halting Problem proof refutation is a tautology thus irrefutable [ liar or incomMr Flibble
| |        || |   | |    `* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |     `* Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |      +- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |      `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |       +* Halting Problem proof refutation is a tautology thus irrefutable [ liar or incomMr Flibble
| |        || |   | |       |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |       | `- Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |       +* Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |       |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | |       | +- Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |   | |       | `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |       `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | +* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |   | | `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   | `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |   `* Halting Problem proof refutation is a tautology thus irrefutableAndré G. Isaak
| |        || |    +- Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |    `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |     +* Halting Problem proof refutation is a tautology thus irrefutableAndré G. Isaak
| |        || |     |`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |     | +* Halting Problem proof refutation is a tautology thus irrefutableAndré G. Isaak
| |        || |     | |`- Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        || |     | `* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |     |  `* Halting Problem proof refutation is a tautology thus irrefutable [ technical comolcott
| |        || |     |   +- Halting Problem proof refutation is a tautology thusMr Flibble
| |        || |     |   `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || |     `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        || `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        |`* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        | `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |  `* Halting Problem proof refutation is a tautology thus irrefutable [ strawman ]Richard Damon
| |        |   `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |    `* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        |     `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |      `* Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        |       `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |        |        `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| |        `* Halting Problem proof refutation is a tautology thus irrefutableolcott
| |         `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| `- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
+* Halting Problem proof refutation is a tautology thus irrefutableMikko
|`* Halting Problem proof refutation is a tautology thus irrefutableolcott
| +- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
| `* Halting Problem proof refutation is a tautology thus irrefutableMikko
|  `* Halting Problem proof refutation is a tautology thus irrefutableolcott
|   +- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon
|   `* Halting Problem proof refutation is a tautology thus irrefutableMikko
|    +- Halting Problem proof refutation is a tautology thusMr Flibble
|    `- Halting Problem proof refutation is a tautology thus irrefutableMr Flibble
`- Halting Problem proof refutation is a tautology thus irrefutableRichard Damon

Pages:1234
Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

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

  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 17:16:03 -0500
Date: Sun, 19 Jun 2022 17:16: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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<--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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619224657.00005e40@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 420
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ftrRLd1k7dmcvLNcxrw6u6fXJ+a483qJ+tqgEjz5w/eKRKe40LBOIE3SanRn9ls0cHLpkxlnEFS1wqz!6Dm2+2N3qOqa+Lu5kF1MPrSsuSj0p11elG8W07/oepspJWV5mA4i3xlsYhcgNaafok/DKEIt7OgP
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: 21499
 by: olcott - Sun, 19 Jun 2022 22:16 UTC

On 6/19/2022 4:46 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 16:23:17 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>> 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.
>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
>>>>>>>>> saying Px doesn't halt. QED.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Every technically competent software engineer can easily
>>>>>>>> confirm that the correct and complete x86 emulation of the
>>>>>>>> input to H(Px,Px) by H would never reach the "ret" instruction
>>>>>>>> of Px.
>>>>>>>>
>>>>>>>> That you can not understand this proves that you are not a
>>>>>>>> sufficiently technically competent software engineer on this
>>>>>>>> point. Very good COBOL programmers might never be able to
>>>>>>>> understand this.
>>>>>>>>
>>>>>>>> To anyone that writes or maintains operating systems what I am
>>>>>>>> claiming would be as easy to verify as first grade arithmetic.
>>>>>>>>
>>>>>>> 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
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Get an operating system programmer to explain to you that the
>>>>>> correct and complete x86 emulation of the input to H(Px,Px) by H
>>>>>> would never reach the "ret" instruction of Px. *This is totally
>>>>>> over your head*
>>>>>>
>>>>>> It is like I am saying that we know that black carts are cats and
>>>>>> you disagree saying the a black cat might be some kind of dog.
>>>>>>
>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>> Studio project on a downloadable link.
>>>>>>
>>>>>
>>>>> No, maybe you need an actual programmer to look at your logic.
>>>>>
>>>>> First, by definition correct emulation of a program will match the
>>>>> behavior of the program.
>>>>>
>>>>
>>>> When you disagree with this precisely stated verified fact you are
>>>> either a liar or incompetent:
>>>>
>>>> the correct and complete x86 emulation of the input to H(Px,Px) by
>>>> H would never reach the "ret" instruction
>>>>
>>>> When you disagree the the above precisely stated verified fact by
>>>> changing its words and showing that the changed words are not true
>>>> then between liar and incompetent you prove to be a liar.
>>>
>>> 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
>>
>>
>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>> the correct and complete x86 emulation of the input to H(Px,Px) by H
>> would never reach the "ret" instruction
>
> What I am saying is the following, no more, no less:
>
> 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 [ strawman ]

<fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

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

  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 17:18:38 -0500
Date: Sun, 19 Jun 2022 17:18:39 -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>
<5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <t8o6eb$h5l$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t8o6eb$h5l$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 20
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-JqORENCOAryqXH/9kFEsdh8N4lq3+q5IlNIflQPBuUj3v1SxL537vKGn83U3l00ZbAT0MFaSm36QtAQ!ftXAczVT/JmXK4guiCXpB3L3JOPcajdDx7sE06wSpqiwdG6LZgYDZOcdRJa/UHDJzOyKrqyjN0e4
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: 2604
 by: olcott - Sun, 19 Jun 2022 22:18 UTC

On 6/19/2022 5:02 PM, André G. Isaak wrote:
> On 2022-06-19 14:43, olcott wrote:
>
>> My whole system is now wrapped in 131K zip file as a Visual Studio
>> project on a downloadable link.
>
> I see no link anywhere.
>
> André
>

Are you sure maybe you didn't look hard enough?
Maybe there is an invisible link between "131K" and "zip"

--
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 [ liar or incompetent ]

<20220619232200.00004368@reddwarf.jmc>

  copy mid

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

  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!peer01.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx10.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 [ liar or incompetent ]
Message-ID: <20220619232200.00004368@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com>
<s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@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: 456
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 22:21:59 UTC
Date: Sun, 19 Jun 2022 23:22:00 +0100
X-Received-Bytes: 23357
X-Original-Bytes: 23213
 by: Mr Flibble - Sun, 19 Jun 2022 22:22 UTC

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

> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 16:23:17 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>> 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.
> >>>>>>>>> Px is defined to always halt; your H gets the answer wrong
> >>>>>>>>> saying Px doesn't halt. QED.
> >>>>>>>>>
> >>>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>> Every technically competent software engineer can easily
> >>>>>>>> confirm that the correct and complete x86 emulation of the
> >>>>>>>> input to H(Px,Px) by H would never reach the "ret"
> >>>>>>>> instruction of Px.
> >>>>>>>>
> >>>>>>>> That you can not understand this proves that you are not a
> >>>>>>>> sufficiently technically competent software engineer on this
> >>>>>>>> point. Very good COBOL programmers might never be able to
> >>>>>>>> understand this.
> >>>>>>>>
> >>>>>>>> To anyone that writes or maintains operating systems what I
> >>>>>>>> am claiming would be as easy to verify as first grade
> >>>>>>>> arithmetic.
> >>>>>>> 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
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> Get an operating system programmer to explain to you that the
> >>>>>> correct and complete x86 emulation of the input to H(Px,Px) by
> >>>>>> H would never reach the "ret" instruction of Px. *This is
> >>>>>> totally over your head*
> >>>>>>
> >>>>>> It is like I am saying that we know that black carts are cats
> >>>>>> and you disagree saying the a black cat might be some kind of
> >>>>>> dog.
> >>>>>>
> >>>>>> My whole system is now wrapped in 131K zip file as a Visual
> >>>>>> Studio project on a downloadable link.
> >>>>>>
> >>>>>
> >>>>> No, maybe you need an actual programmer to look at your logic.
> >>>>>
> >>>>> First, by definition correct emulation of a program will match
> >>>>> the behavior of the program.
> >>>>>
> >>>>
> >>>> When you disagree with this precisely stated verified fact you
> >>>> are either a liar or incompetent:
> >>>>
> >>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>> by H would never reach the "ret" instruction
> >>>>
> >>>> When you disagree the the above precisely stated verified fact by
> >>>> changing its words and showing that the changed words are not
> >>>> true then between liar and incompetent you prove to be a liar.
> >>>
> >>> 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
> >>
> >>
> >> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >> the correct and complete x86 emulation of the input to H(Px,Px) by
> >> H would never reach the "ret" instruction
> >
> > What I am saying is the following, no more, no less:
> >
> > 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
> >
> >
>
> You are not committing to a criterion measure of correctness thus
> your claim is vague.

Click here to read the complete article

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

<meOdnXsemI-hPzL_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  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 17:25:00 -0500
Date: Sun, 19 Jun 2022 17:25: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
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>
<_wLrK.111624$ntj.61667@fx15.iad>
<icGdnRYyOvGmFTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<y_LrK.135800$vZ1.122985@fx04.iad>
<ttOdnbX_X4GyEDL_nZ2dnUU7_83NnZ2d@giganews.com>
<8tMrK.139614$X_i.88191@fx18.iad>
<wq6dnUyFns7NCzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<mYMrK.111636$ntj.97546@fx15.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <mYMrK.111636$ntj.97546@fx15.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <meOdnXsemI-hPzL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 368
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-erYPMQcZt0FYLf9Q4mrOPNG2jZ/E54uRx8ny03OXaDggaaf4Q7hXR8V/NZkaMMhxIhmKF5ZbwrrwoPh!CB+oWVHs7Zmp5Pre+Ep1n22DnIkE+KpwIPco5I8vicl2bCvVFAZ95bSXTmUS10E4+JHLUbSEHeZI
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: 18038
 by: olcott - Sun, 19 Jun 2022 22:25 UTC

On 6/19/2022 4:56 PM, Richard Damon wrote:
> On 6/19/22 5:34 PM, olcott wrote:
>> On 6/19/2022 4:23 PM, Richard Damon wrote:
>>>
>>> On 6/19/22 4:55 PM, olcott wrote:
>>>> On 6/19/2022 3:50 PM, Richard Damon wrote:
>>>>> On 6/19/22 4:34 PM, olcott wrote:
>>>>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 6/19/22 3:17 PM, olcott 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.
>>>>>>>
>>>>>>> What "Future Tense".
>>>>>> A halt decider must always correctly determine whether or not its
>>>>>> input WOULD halt. If halt deciders reported what the behavior of
>>>>>> its input
>>>>>> DOES then like you said it would never report on non halting inputs.
>>>>>>
>>>>>> All non-simulating halt deciders can only report on what their input
>>>>>> WOULD do and not what their input DOES because non-simulating halt
>>>>>> deciders are static rather than dynamic analyzers.
>>>>>>
>>>>>
>>>>> Would only in the sense of condition of testing, not time.
>>>> Halt deciders must always predict what their non-halting inputs
>>>> would do in the future if they were executed.
>>>
>>> Why?
>>>
>>> There is no actual requirement to execute the machine, only know what
>>> would happen if at some point we did do that execution either in the
>>> past or the future.
>>>
>>>>
>>>> They can never report on the non-halting behavior of what their
>>>> inputs did do in the past.
>>>
>>> Why not?
>>
>> If they are simulating halt deciders they can
>> never report on
>> never report on
>> never report on
>> never report on
>> never report on
>>
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>>
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>> of what their inputs did do in the past
>>
>> Because as you have said 1000 times they would be
>> stuck simulating this non-halting input forever.
>>
>> If they are not simulating halt deciders they can
>> never report on
>> never report on
>> never report on
>> never report on
>> never report on
>>
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>> the non-halting behavior
>>
>> Because they are not even examining behavior they are
>> only static analyzers that do not look at dynamic behavior.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>> Therefore halt deciders can never report on the non-halting behavior
>> of what their inputs did do in the past.
>>
>>
>
> Regressing back to a two year old again I see.


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

<ZpWdnVQPXMJQPjL_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  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 17:31:41 -0500
Date: Sun, 19 Jun 2022 17:31:40 -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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619232200.00004368@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <ZpWdnVQPXMJQPjL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 449
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-16WoLrmDzhB1ue8787yWunvTg+XcFyqgopM9GJiAbt/MUYHNQdrTthV8SoMP6oe+1VT7XLmMhLfHSmo!DVLPt8KWcbdOOdNRYTGJclLgnekyDa19Ho3d2O130gFP5jqZpnFbkXz0uHQ1x5H/91wxTWsO19WG
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: 23202
 by: olcott - Sun, 19 Jun 2022 22:31 UTC

On 6/19/2022 5:22 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 17:16:03 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
>>>>>>>>>>> saying Px doesn't halt. QED.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>> confirm that the correct and complete x86 emulation of the
>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>> instruction of Px.
>>>>>>>>>>
>>>>>>>>>> That you can not understand this proves that you are not a
>>>>>>>>>> sufficiently technically competent software engineer on this
>>>>>>>>>> point. Very good COBOL programmers might never be able to
>>>>>>>>>> understand this.
>>>>>>>>>>
>>>>>>>>>> To anyone that writes or maintains operating systems what I
>>>>>>>>>> am claiming would be as easy to verify as first grade
>>>>>>>>>> arithmetic.
>>>>>>>>> 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
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Get an operating system programmer to explain to you that the
>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px) by
>>>>>>>> H would never reach the "ret" instruction of Px. *This is
>>>>>>>> totally over your head*
>>>>>>>>
>>>>>>>> It is like I am saying that we know that black carts are cats
>>>>>>>> and you disagree saying the a black cat might be some kind of
>>>>>>>> dog.
>>>>>>>>
>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>> Studio project on a downloadable link.
>>>>>>>>
>>>>>>>
>>>>>>> No, maybe you need an actual programmer to look at your logic.
>>>>>>>
>>>>>>> First, by definition correct emulation of a program will match
>>>>>>> the behavior of the program.
>>>>>>>
>>>>>>
>>>>>> When you disagree with this precisely stated verified fact you
>>>>>> are either a liar or incompetent:
>>>>>>
>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>> by H would never reach the "ret" instruction
>>>>>>
>>>>>> When you disagree the the above precisely stated verified fact by
>>>>>> changing its words and showing that the changed words are not
>>>>>> true then between liar and incompetent you prove to be a liar.
>>>>>
>>>>> 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
>>>>
>>>>
>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>> the correct and complete x86 emulation of the input to H(Px,Px) by
>>>> H would never reach the "ret" instruction
>>>
>>> What I am saying is the following, no more, no less:
>>>
>>> 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
>>>
>>>
>>
>> You are not committing to a criterion measure of correctness thus
>> your claim is vague.
>
> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
> decides that it is non-halting.
>
> /Flibble
>


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

<20220619233414.000024e2@reddwarf.jmc>

  copy mid

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

  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!tr2.eu1.usenetexpress.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx10.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 [ liar or incompetent ]
Message-ID: <20220619233414.000024e2@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com> <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> <20220619210812.00003001@reddwarf.jmc> <6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com> <20220619213137.00004b36@reddwarf.jmc> <LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad> <K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com> <20220619222001.00006585@reddwarf.jmc> <aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com> <20220619224657.00005e40@reddwarf.jmc> <fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com> <20220619232200.00004368@reddwarf.jmc> <ZpWdnVQPXMJQPjL_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: 511
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 22:34:14 UTC
Date: Sun, 19 Jun 2022 23:34:14 +0100
X-Received-Bytes: 25654
 by: Mr Flibble - Sun, 19 Jun 2022 22:34 UTC

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

> On 6/19/2022 5:22 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 17:16:03 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>> 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.
> >>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
> >>>>>>>>>>> saying Px doesn't halt. QED.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>> Every technically competent software engineer can easily
> >>>>>>>>>> confirm that the correct and complete x86 emulation of the
> >>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
> >>>>>>>>>> instruction of Px.
> >>>>>>>>>>
> >>>>>>>>>> That you can not understand this proves that you are not a
> >>>>>>>>>> sufficiently technically competent software engineer on
> >>>>>>>>>> this point. Very good COBOL programmers might never be
> >>>>>>>>>> able to understand this.
> >>>>>>>>>>
> >>>>>>>>>> To anyone that writes or maintains operating systems what I
> >>>>>>>>>> am claiming would be as easy to verify as first grade
> >>>>>>>>>> arithmetic.
> >>>>>>>>> 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
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Get an operating system programmer to explain to you that the
> >>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
> >>>>>>>> by H would never reach the "ret" instruction of Px. *This is
> >>>>>>>> totally over your head*
> >>>>>>>>
> >>>>>>>> It is like I am saying that we know that black carts are cats
> >>>>>>>> and you disagree saying the a black cat might be some kind of
> >>>>>>>> dog.
> >>>>>>>>
> >>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
> >>>>>>>> Studio project on a downloadable link.
> >>>>>>>>
> >>>>>>>
> >>>>>>> No, maybe you need an actual programmer to look at your logic.
> >>>>>>>
> >>>>>>> First, by definition correct emulation of a program will match
> >>>>>>> the behavior of the program.
> >>>>>>>
> >>>>>>
> >>>>>> When you disagree with this precisely stated verified fact you
> >>>>>> are either a liar or incompetent:
> >>>>>>
> >>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>>>> by H would never reach the "ret" instruction
> >>>>>>
> >>>>>> When you disagree the the above precisely stated verified fact
> >>>>>> by changing its words and showing that the changed words are
> >>>>>> not true then between liar and incompetent you prove to be a
> >>>>>> liar.
> >>>>>
> >>>>> 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
> >>>>
> >>>>
> >>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>> by H would never reach the "ret" instruction
> >>>
> >>> What I am saying is the following, no more, no less:
> >>>
> >>> 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
> >>>
> >>>
> >>
> >> You are not committing to a criterion measure of correctness thus
> >> your claim is vague.
> >
> > Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
> > decides that it is non-halting.
> >
> > /Flibble
> >
>
> Flibble knows that he is so woefully incompetent that he refuses to
> answer whether or not the following is true or false:
>
> the correct and complete x86 emulation of the input to H(Px,Px) by
> H would never reach the "ret" instruction
>
> If one has no idea whether or not a statement is true or false and
> they want to hide the fact that they have no idea then when
> repeatedly pressed to provide an answer the best that they can
> possibly do is continue to dodge the question.
>
> it is no longer worth my time to continue to talk to you of Richard.

Click here to read the complete article

Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

<QNNrK.139616$X_i.21563@fx18.iad>

  copy mid

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

  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!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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <20220619232200.00004368@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 439
Message-ID: <QNNrK.139616$X_i.21563@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 18:53:36 -0400
X-Received-Bytes: 22547
 by: Richard Damon - Sun, 19 Jun 2022 22:53 UTC

On 6/19/22 6:22 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 17:16:03 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>> 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.
>>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
>>>>>>>>>>> saying Px doesn't halt. QED.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>> confirm that the correct and complete x86 emulation of the
>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>> instruction of Px.
>>>>>>>>>>
>>>>>>>>>> That you can not understand this proves that you are not a
>>>>>>>>>> sufficiently technically competent software engineer on this
>>>>>>>>>> point. Very good COBOL programmers might never be able to
>>>>>>>>>> understand this.
>>>>>>>>>>
>>>>>>>>>> To anyone that writes or maintains operating systems what I
>>>>>>>>>> am claiming would be as easy to verify as first grade
>>>>>>>>>> arithmetic.
>>>>>>>>> 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
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Get an operating system programmer to explain to you that the
>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px) by
>>>>>>>> H would never reach the "ret" instruction of Px. *This is
>>>>>>>> totally over your head*
>>>>>>>>
>>>>>>>> It is like I am saying that we know that black carts are cats
>>>>>>>> and you disagree saying the a black cat might be some kind of
>>>>>>>> dog.
>>>>>>>>
>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>> Studio project on a downloadable link.
>>>>>>>>
>>>>>>>
>>>>>>> No, maybe you need an actual programmer to look at your logic.
>>>>>>>
>>>>>>> First, by definition correct emulation of a program will match
>>>>>>> the behavior of the program.
>>>>>>>
>>>>>>
>>>>>> When you disagree with this precisely stated verified fact you
>>>>>> are either a liar or incompetent:
>>>>>>
>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>> by H would never reach the "ret" instruction
>>>>>>
>>>>>> When you disagree the the above precisely stated verified fact by
>>>>>> changing its words and showing that the changed words are not
>>>>>> true then between liar and incompetent you prove to be a liar.
>>>>>
>>>>> 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
>>>>
>>>>
>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>> the correct and complete x86 emulation of the input to H(Px,Px) by
>>>> H would never reach the "ret" instruction
>>>
>>> What I am saying is the following, no more, no less:
>>>
>>> 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
>>>
>>>
>>
>> You are not committing to a criterion measure of correctness thus
>> your claim is vague.
>
> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
> decides that it is non-halting.
>
> /Flibble
>


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

<20220619235825.000032bf@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!news-out.netnews.com!news.alt.net!fdc2.netnews.com!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx10.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 [ liar or incompetent ]
Message-ID: <20220619235825.000032bf@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com>
<s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc>
<QNNrK.139616$X_i.21563@fx18.iad>
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: 478
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 22:58:25 UTC
Date: Sun, 19 Jun 2022 23:58:25 +0100
X-Received-Bytes: 24645
 by: Mr Flibble - Sun, 19 Jun 2022 22:58 UTC

On Sun, 19 Jun 2022 18:53:36 -0400
Richard Damon <Richard@Damon-Family.org> wrote:

> On 6/19/22 6:22 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 17:16:03 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>> 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.
> >>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
> >>>>>>>>>>> saying Px doesn't halt. QED.
> >>>>>>>>>>>
> >>>>>>>>>>> /Flibble
> >>>>>>>>>>
> >>>>>>>>>> Every technically competent software engineer can easily
> >>>>>>>>>> confirm that the correct and complete x86 emulation of the
> >>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
> >>>>>>>>>> instruction of Px.
> >>>>>>>>>>
> >>>>>>>>>> That you can not understand this proves that you are not a
> >>>>>>>>>> sufficiently technically competent software engineer on
> >>>>>>>>>> this point. Very good COBOL programmers might never be
> >>>>>>>>>> able to understand this.
> >>>>>>>>>>
> >>>>>>>>>> To anyone that writes or maintains operating systems what I
> >>>>>>>>>> am claiming would be as easy to verify as first grade
> >>>>>>>>>> arithmetic.
> >>>>>>>>> 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
> >>>>>>>>>
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Get an operating system programmer to explain to you that the
> >>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
> >>>>>>>> by H would never reach the "ret" instruction of Px. *This is
> >>>>>>>> totally over your head*
> >>>>>>>>
> >>>>>>>> It is like I am saying that we know that black carts are cats
> >>>>>>>> and you disagree saying the a black cat might be some kind of
> >>>>>>>> dog.
> >>>>>>>>
> >>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
> >>>>>>>> Studio project on a downloadable link.
> >>>>>>>>
> >>>>>>>
> >>>>>>> No, maybe you need an actual programmer to look at your logic.
> >>>>>>>
> >>>>>>> First, by definition correct emulation of a program will match
> >>>>>>> the behavior of the program.
> >>>>>>>
> >>>>>>
> >>>>>> When you disagree with this precisely stated verified fact you
> >>>>>> are either a liar or incompetent:
> >>>>>>
> >>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>>>> by H would never reach the "ret" instruction
> >>>>>>
> >>>>>> When you disagree the the above precisely stated verified fact
> >>>>>> by changing its words and showing that the changed words are
> >>>>>> not true then between liar and incompetent you prove to be a
> >>>>>> liar.
> >>>>>
> >>>>> 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
> >>>>
> >>>>
> >>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>> by H would never reach the "ret" instruction
> >>>
> >>> What I am saying is the following, no more, no less:
> >>>
> >>> 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
> >>>
> >>>
> >>
> >> You are not committing to a criterion measure of correctness thus
> >> your claim is vague.
> >
> > Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
> > decides that it is non-halting.
> >
> > /Flibble
> >
>
> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
> it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
>
> Now, this H fails to be a decider, so can't be a counter example for
> a Halt Decider.


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

<lWNrK.251141$J0r9.92507@fx11.iad>

  copy mid

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

  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!fx11.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
[ 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>
<_wLrK.111624$ntj.61667@fx15.iad>
<icGdnRYyOvGmFTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<y_LrK.135800$vZ1.122985@fx04.iad>
<ttOdnbX_X4GyEDL_nZ2dnUU7_83NnZ2d@giganews.com>
<8tMrK.139614$X_i.88191@fx18.iad>
<wq6dnUyFns7NCzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<mYMrK.111636$ntj.97546@fx15.iad>
<meOdnXsemI-hPzL_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <meOdnXsemI-hPzL_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 398
Message-ID: <lWNrK.251141$J0r9.92507@fx11.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 19:02:40 -0400
X-Received-Bytes: 19534
 by: Richard Damon - Sun, 19 Jun 2022 23:02 UTC

On 6/19/22 6:25 PM, olcott wrote:
> On 6/19/2022 4:56 PM, Richard Damon wrote:
>> On 6/19/22 5:34 PM, olcott wrote:
>>> On 6/19/2022 4:23 PM, Richard Damon wrote:
>>>>
>>>> On 6/19/22 4:55 PM, olcott wrote:
>>>>> On 6/19/2022 3:50 PM, Richard Damon wrote:
>>>>>> On 6/19/22 4:34 PM, olcott wrote:
>>>>>>> On 6/19/2022 3:19 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 6/19/22 3:17 PM, olcott 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.
>>>>>>>>
>>>>>>>> What "Future Tense".
>>>>>>> A halt decider must always correctly determine whether or not its
>>>>>>> input WOULD halt. If halt deciders reported what the behavior of
>>>>>>> its input
>>>>>>> DOES then like you said it would never report on non halting inputs.
>>>>>>>
>>>>>>> All non-simulating halt deciders can only report on what their input
>>>>>>> WOULD do and not what their input DOES because non-simulating halt
>>>>>>> deciders are static rather than dynamic analyzers.
>>>>>>>
>>>>>>
>>>>>> Would only in the sense of condition of testing, not time.
>>>>> Halt deciders must always predict what their non-halting inputs
>>>>> would do in the future if they were executed.
>>>>
>>>> Why?
>>>>
>>>> There is no actual requirement to execute the machine, only know
>>>> what would happen if at some point we did do that execution either
>>>> in the past or the future.
>>>>
>>>>>
>>>>> They can never report on the non-halting behavior of what their
>>>>> inputs did do in the past.
>>>>
>>>> Why not?
>>>
>>> If they are simulating halt deciders they can
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>>
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>>
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>> of what their inputs did do in the past
>>>
>>> Because as you have said 1000 times they would be
>>> stuck simulating this non-halting input forever.
>>>
>>> If they are not simulating halt deciders they can
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>> never report on
>>>
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>> the non-halting behavior
>>>
>>> Because they are not even examining behavior they are
>>> only static analyzers that do not look at dynamic behavior.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>> Therefore halt deciders can never report on the non-halting behavior
>>> of what their inputs did do in the past.
>>>
>>>
>>
>> Regressing back to a two year old again I see.
>
> That I have to tell you the same thing hundreds and hundreds of times
> before you notice that I said it once is best handled by plonking you.


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

<%YNrK.251142$J0r9.141217@fx11.iad>

  copy mid

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

  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!fx11.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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <20220619235825.000032bf@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 462
Message-ID: <%YNrK.251142$J0r9.141217@fx11.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 19:05:31 -0400
X-Received-Bytes: 24095
 by: Richard Damon - Sun, 19 Jun 2022 23:05 UTC

On 6/19/22 6:58 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 18:53:36 -0400
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 6/19/22 6:22 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 17:16:03 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
>>>>>>>>>>>>> saying Px doesn't halt. QED.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>>>> confirm that the correct and complete x86 emulation of the
>>>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>>>> instruction of Px.
>>>>>>>>>>>>
>>>>>>>>>>>> That you can not understand this proves that you are not a
>>>>>>>>>>>> sufficiently technically competent software engineer on
>>>>>>>>>>>> this point. Very good COBOL programmers might never be
>>>>>>>>>>>> able to understand this.
>>>>>>>>>>>>
>>>>>>>>>>>> To anyone that writes or maintains operating systems what I
>>>>>>>>>>>> am claiming would be as easy to verify as first grade
>>>>>>>>>>>> arithmetic.
>>>>>>>>>>> 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
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Get an operating system programmer to explain to you that the
>>>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>>>> by H would never reach the "ret" instruction of Px. *This is
>>>>>>>>>> totally over your head*
>>>>>>>>>>
>>>>>>>>>> It is like I am saying that we know that black carts are cats
>>>>>>>>>> and you disagree saying the a black cat might be some kind of
>>>>>>>>>> dog.
>>>>>>>>>>
>>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>>>> Studio project on a downloadable link.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, maybe you need an actual programmer to look at your logic.
>>>>>>>>>
>>>>>>>>> First, by definition correct emulation of a program will match
>>>>>>>>> the behavior of the program.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When you disagree with this precisely stated verified fact you
>>>>>>>> are either a liar or incompetent:
>>>>>>>>
>>>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>> by H would never reach the "ret" instruction
>>>>>>>>
>>>>>>>> When you disagree the the above precisely stated verified fact
>>>>>>>> by changing its words and showing that the changed words are
>>>>>>>> not true then between liar and incompetent you prove to be a
>>>>>>>> liar.
>>>>>>>
>>>>>>> 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
>>>>>>
>>>>>>
>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>> by H would never reach the "ret" instruction
>>>>>
>>>>> What I am saying is the following, no more, no less:
>>>>>
>>>>> 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
>>>>>
>>>>>
>>>>
>>>> You are not committing to a criterion measure of correctness thus
>>>> your claim is vague.
>>>
>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
>>> decides that it is non-halting.
>>>
>>> /Flibble
>>>
>>
>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
>> it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
>>
>> Now, this H fails to be a decider, so can't be a counter example for
>> a Halt Decider.
>
> If H is a valid halt decider (and by that I mean returns an answer in
> finite time) then Px *will* always halt: it doesn't because Olcott's H
> is not a valid halt decider.
>
> /Flibble
>


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

<nfOrK.302946$zgr9.72193@fx13.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.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
[ liar or incompetent ]
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>
<5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 10
Message-ID: <nfOrK.302946$zgr9.72193@fx13.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 19:25:06 -0400
X-Received-Bytes: 2178
 by: Richard Damon - Sun, 19 Jun 2022 23:25 UTC

On 6/19/22 5:17 PM, olcott wrote:
>
> When you disagree with this precisely stated verified fact you are
> either a liar or incompetent:

And when you state facts have been "verified" when they haven't, your a
liar.

Maybe you are too dumb to realize that your "proofs" have been rebutted,
but using stupidity as an excuse only goes so far.

Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  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 18:25:33 -0500
Date: Sun, 19 Jun 2022 18:25:33 -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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220619235825.000032bf@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 474
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-u7TnPYh1kUN6s5nhlyyKqG+E8FlwQpkwvSQSH+J39ncbg5wMUlu/y1tpM++LZ0+OfT5c4g1rgTY08UJ!G7pZ+C91OxIwsFQbGG3M+l4iy5zHq33BJHADl/v03l6/GM4KgQdSkJdm9xmt7jzFYIoMOuRx5Qlx
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: 24693
 by: olcott - Sun, 19 Jun 2022 23:25 UTC

On 6/19/2022 5:58 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 18:53:36 -0400
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 6/19/22 6:22 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 17:16:03 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
>>>>>>>>>>>>> saying Px doesn't halt. QED.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>>>> confirm that the correct and complete x86 emulation of the
>>>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>>>> instruction of Px.
>>>>>>>>>>>>
>>>>>>>>>>>> That you can not understand this proves that you are not a
>>>>>>>>>>>> sufficiently technically competent software engineer on
>>>>>>>>>>>> this point. Very good COBOL programmers might never be
>>>>>>>>>>>> able to understand this.
>>>>>>>>>>>>
>>>>>>>>>>>> To anyone that writes or maintains operating systems what I
>>>>>>>>>>>> am claiming would be as easy to verify as first grade
>>>>>>>>>>>> arithmetic.
>>>>>>>>>>> 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
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Get an operating system programmer to explain to you that the
>>>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>>>> by H would never reach the "ret" instruction of Px. *This is
>>>>>>>>>> totally over your head*
>>>>>>>>>>
>>>>>>>>>> It is like I am saying that we know that black carts are cats
>>>>>>>>>> and you disagree saying the a black cat might be some kind of
>>>>>>>>>> dog.
>>>>>>>>>>
>>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>>>> Studio project on a downloadable link.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, maybe you need an actual programmer to look at your logic.
>>>>>>>>>
>>>>>>>>> First, by definition correct emulation of a program will match
>>>>>>>>> the behavior of the program.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When you disagree with this precisely stated verified fact you
>>>>>>>> are either a liar or incompetent:
>>>>>>>>
>>>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>> by H would never reach the "ret" instruction
>>>>>>>>
>>>>>>>> When you disagree the the above precisely stated verified fact
>>>>>>>> by changing its words and showing that the changed words are
>>>>>>>> not true then between liar and incompetent you prove to be a
>>>>>>>> liar.
>>>>>>>
>>>>>>> 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
>>>>>>
>>>>>>
>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>> by H would never reach the "ret" instruction
>>>>>
>>>>> What I am saying is the following, no more, no less:
>>>>>
>>>>> 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
>>>>>
>>>>>
>>>>
>>>> You are not committing to a criterion measure of correctness thus
>>>> your claim is vague.
>>>
>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
>>> decides that it is non-halting.
>>>
>>> /Flibble
>>>
>>
>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
>> it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
>>
>> Now, this H fails to be a decider, so can't be a counter example for
>> a Halt Decider.
>
> If H is a valid halt decider (and by that I mean returns an answer in
> finite time) then Px *will* always halt: it doesn't because Olcott's H
> is not a valid halt decider.
>
> /Flibble
>


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

<20220620002732.000016f9@reddwarf.jmc>

  copy mid

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

  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!fx10.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 [ liar or incompetent ]
Message-ID: <20220620002732.000016f9@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com> <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> <20220619210812.00003001@reddwarf.jmc> <6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com> <20220619213137.00004b36@reddwarf.jmc> <LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad> <K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com> <20220619222001.00006585@reddwarf.jmc> <aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com> <20220619224657.00005e40@reddwarf.jmc> <fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com> <20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad> <20220619235825.000032bf@reddwarf.jmc> <pcednU2mH_jwLTL_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: 525
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 23:27:32 UTC
Date: Mon, 20 Jun 2022 00:27:32 +0100
X-Received-Bytes: 26954
 by: Mr Flibble - Sun, 19 Jun 2022 23:27 UTC

On Sun, 19 Jun 2022 18:25:33 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 5:58 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 18:53:36 -0400
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 6/19/22 6:22 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 17:16:03 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> 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.
> >>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
> >>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> Every technically competent software engineer can easily
> >>>>>>>>>>>> confirm that the correct and complete x86 emulation of
> >>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret"
> >>>>>>>>>>>> instruction of Px.
> >>>>>>>>>>>>
> >>>>>>>>>>>> That you can not understand this proves that you are not
> >>>>>>>>>>>> a sufficiently technically competent software engineer on
> >>>>>>>>>>>> this point. Very good COBOL programmers might never be
> >>>>>>>>>>>> able to understand this.
> >>>>>>>>>>>>
> >>>>>>>>>>>> To anyone that writes or maintains operating systems
> >>>>>>>>>>>> what I am claiming would be as easy to verify as first
> >>>>>>>>>>>> grade arithmetic.
> >>>>>>>>>>> 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
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Get an operating system programmer to explain to you that
> >>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
> >>>>>>>>>> Px. *This is totally over your head*
> >>>>>>>>>>
> >>>>>>>>>> It is like I am saying that we know that black carts are
> >>>>>>>>>> cats and you disagree saying the a black cat might be some
> >>>>>>>>>> kind of dog.
> >>>>>>>>>>
> >>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
> >>>>>>>>>> Studio project on a downloadable link.
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> No, maybe you need an actual programmer to look at your
> >>>>>>>>> logic.
> >>>>>>>>>
> >>>>>>>>> First, by definition correct emulation of a program will
> >>>>>>>>> match the behavior of the program.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> When you disagree with this precisely stated verified fact
> >>>>>>>> you are either a liar or incompetent:
> >>>>>>>>
> >>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>>
> >>>>>>>> When you disagree the the above precisely stated verified
> >>>>>>>> fact by changing its words and showing that the changed
> >>>>>>>> words are not true then between liar and incompetent you
> >>>>>>>> prove to be a liar.
> >>>>>>>
> >>>>>>> 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
> >>>>>>
> >>>>>>
> >>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>>>> by H would never reach the "ret" instruction
> >>>>>
> >>>>> What I am saying is the following, no more, no less:
> >>>>>
> >>>>> 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
> >>>>>
> >>>>>
> >>>>
> >>>> You are not committing to a criterion measure of correctness thus
> >>>> your claim is vague.
> >>>
> >>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
> >>> your H decides that it is non-halting.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
> >> because it gets stuck in an infinite loop, then Px(Px) doesn't
> >> Halt.
> >>
> >> Now, this H fails to be a decider, so can't be a counter example
> >> for a Halt Decider.
> >
> > If H is a valid halt decider (and by that I mean returns an answer
> > in finite time) then Px *will* always halt: it doesn't because
> > Olcott's H is not a valid halt decider.
> >
> > /Flibble
> >
>
> Now that H has been very recently adapted to be a pure function of
> its inputs whenever it is invoked it always returns on finite time.
> H aborts its simulation of Px before Px invokes H.
>
> 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 its call to H is invoked.


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

<XbqdnSuVlq1SLDL_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

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

  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 18:31:27 -0500
Date: Sun, 19 Jun 2022 18:31:27 -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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220620002732.000016f9@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220620002732.000016f9@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <XbqdnSuVlq1SLDL_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 515
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rpEiPL8haELWVwWunQhzh96l/rkc4iJ7n1i2qkKS62Z07VrUJmi99JKDI3kFR5dw1mJMeQsWQ+1WD+d!HfozknaOHve+shZYTdqjST56FTwXRZoOobofWsxWL/wbEIpxSIs7mu6tu6489OK62HhxvImzilPU
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: 26795
 by: olcott - Sun, 19 Jun 2022 23:31 UTC

On 6/19/2022 6:27 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 18:25:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 5:58 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 18:53:36 -0400
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 17:16:03 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
>>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>>>>>> confirm that the correct and complete x86 emulation of
>>>>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>>>>>> instruction of Px.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That you can not understand this proves that you are not
>>>>>>>>>>>>>> a sufficiently technically competent software engineer on
>>>>>>>>>>>>>> this point. Very good COBOL programmers might never be
>>>>>>>>>>>>>> able to understand this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To anyone that writes or maintains operating systems
>>>>>>>>>>>>>> what I am claiming would be as easy to verify as first
>>>>>>>>>>>>>> grade arithmetic.
>>>>>>>>>>>>> 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
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Get an operating system programmer to explain to you that
>>>>>>>>>>>> the correct and complete x86 emulation of the input to
>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
>>>>>>>>>>>> Px. *This is totally over your head*
>>>>>>>>>>>>
>>>>>>>>>>>> It is like I am saying that we know that black carts are
>>>>>>>>>>>> cats and you disagree saying the a black cat might be some
>>>>>>>>>>>> kind of dog.
>>>>>>>>>>>>
>>>>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>>>>>> Studio project on a downloadable link.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, maybe you need an actual programmer to look at your
>>>>>>>>>>> logic.
>>>>>>>>>>>
>>>>>>>>>>> First, by definition correct emulation of a program will
>>>>>>>>>>> match the behavior of the program.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When you disagree with this precisely stated verified fact
>>>>>>>>>> you are either a liar or incompetent:
>>>>>>>>>>
>>>>>>>>>> the correct and complete x86 emulation of the input to
>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
>>>>>>>>>>
>>>>>>>>>> When you disagree the the above precisely stated verified
>>>>>>>>>> fact by changing its words and showing that the changed
>>>>>>>>>> words are not true then between liar and incompetent you
>>>>>>>>>> prove to be a liar.
>>>>>>>>>
>>>>>>>>> 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
>>>>>>>>
>>>>>>>>
>>>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>> by H would never reach the "ret" instruction
>>>>>>>
>>>>>>> What I am saying is the following, no more, no less:
>>>>>>>
>>>>>>> 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
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> You are not committing to a criterion measure of correctness thus
>>>>>> your claim is vague.
>>>>>
>>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
>>>>> your H decides that it is non-halting.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
>>>> because it gets stuck in an infinite loop, then Px(Px) doesn't
>>>> Halt.
>>>>
>>>> Now, this H fails to be a decider, so can't be a counter example
>>>> for a Halt Decider.
>>>
>>> If H is a valid halt decider (and by that I mean returns an answer
>>> in finite time) then Px *will* always halt: it doesn't because
>>> Olcott's H is not a valid halt decider.
>>>
>>> /Flibble
>>>
>>
>> Now that H has been very recently adapted to be a pure function of
>> its inputs whenever it is invoked it always returns on finite time.
>> H aborts its simulation of Px before Px invokes H.
>>
>> 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 its call to H is invoked.
>
> 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 [ liar or incompetent ]

<20220620003212.000016ce@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx10.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 [ liar or incompetent ]
Message-ID: <20220620003212.000016ce@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com>
<s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc>
<QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_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: 503
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 23:32:12 UTC
Date: Mon, 20 Jun 2022 00:32:12 +0100
X-Received-Bytes: 26331
 by: Mr Flibble - Sun, 19 Jun 2022 23:32 UTC

On Sun, 19 Jun 2022 18:25:33 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 5:58 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 18:53:36 -0400
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 6/19/22 6:22 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 17:16:03 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>
> >>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> 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.
> >>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
> >>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> Every technically competent software engineer can easily
> >>>>>>>>>>>> confirm that the correct and complete x86 emulation of
> >>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret"
> >>>>>>>>>>>> instruction of Px.
> >>>>>>>>>>>>
> >>>>>>>>>>>> That you can not understand this proves that you are not
> >>>>>>>>>>>> a sufficiently technically competent software engineer on
> >>>>>>>>>>>> this point. Very good COBOL programmers might never be
> >>>>>>>>>>>> able to understand this.
> >>>>>>>>>>>>
> >>>>>>>>>>>> To anyone that writes or maintains operating systems
> >>>>>>>>>>>> what I am claiming would be as easy to verify as first
> >>>>>>>>>>>> grade arithmetic.
> >>>>>>>>>>> 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
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> Get an operating system programmer to explain to you that
> >>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
> >>>>>>>>>> Px. *This is totally over your head*
> >>>>>>>>>>
> >>>>>>>>>> It is like I am saying that we know that black carts are
> >>>>>>>>>> cats and you disagree saying the a black cat might be some
> >>>>>>>>>> kind of dog.
> >>>>>>>>>>
> >>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
> >>>>>>>>>> Studio project on a downloadable link.
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> No, maybe you need an actual programmer to look at your
> >>>>>>>>> logic.
> >>>>>>>>>
> >>>>>>>>> First, by definition correct emulation of a program will
> >>>>>>>>> match the behavior of the program.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> When you disagree with this precisely stated verified fact
> >>>>>>>> you are either a liar or incompetent:
> >>>>>>>>
> >>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>>
> >>>>>>>> When you disagree the the above precisely stated verified
> >>>>>>>> fact by changing its words and showing that the changed
> >>>>>>>> words are not true then between liar and incompetent you
> >>>>>>>> prove to be a liar.
> >>>>>>>
> >>>>>>> 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
> >>>>>>
> >>>>>>
> >>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
> >>>>>> by H would never reach the "ret" instruction
> >>>>>
> >>>>> What I am saying is the following, no more, no less:
> >>>>>
> >>>>> 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
> >>>>>
> >>>>>
> >>>>
> >>>> You are not committing to a criterion measure of correctness thus
> >>>> your claim is vague.
> >>>
> >>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
> >>> your H decides that it is non-halting.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
> >> because it gets stuck in an infinite loop, then Px(Px) doesn't
> >> Halt.
> >>
> >> Now, this H fails to be a decider, so can't be a counter example
> >> for a Halt Decider.
> >
> > If H is a valid halt decider (and by that I mean returns an answer
> > in finite time) then Px *will* always halt: it doesn't because
> > Olcott's H is not a valid halt decider.
> >
> > /Flibble
> >
>
> Now that H has been very recently adapted to be a pure function of
> its inputs whenever it is invoked it always returns on finite time.
> H aborts its simulation of Px before Px invokes H.
>
> 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 its call to H is invoked.


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

<20220620003949.000067ee@reddwarf.jmc>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx10.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 [ liar or incompetent ]
Message-ID: <20220620003949.000067ee@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com>
<s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc>
<QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220620002732.000016f9@reddwarf.jmc>
<XbqdnSuVlq1SLDL_nZ2dnUU7_81g4p2d@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: 547
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 23:39:49 UTC
Date: Mon, 20 Jun 2022 00:39:49 +0100
X-Received-Bytes: 28486
 by: Mr Flibble - Sun, 19 Jun 2022 23:39 UTC

On Sun, 19 Jun 2022 18:31:27 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 6/19/2022 6:27 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 18:25:33 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 5:58 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 18:53:36 -0400
> >>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>
> >>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 17:16:03 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
> >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Every technically competent software engineer can
> >>>>>>>>>>>>>> easily confirm that the correct and complete x86
> >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H would never
> >>>>>>>>>>>>>> reach the "ret" instruction of Px.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> That you can not understand this proves that you are
> >>>>>>>>>>>>>> not a sufficiently technically competent software
> >>>>>>>>>>>>>> engineer on this point. Very good COBOL programmers
> >>>>>>>>>>>>>> might never be able to understand this.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> To anyone that writes or maintains operating systems
> >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first
> >>>>>>>>>>>>>> grade arithmetic.
> >>>>>>>>>>>>> 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
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Get an operating system programmer to explain to you that
> >>>>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
> >>>>>>>>>>>> Px. *This is totally over your head*
> >>>>>>>>>>>>
> >>>>>>>>>>>> It is like I am saying that we know that black carts are
> >>>>>>>>>>>> cats and you disagree saying the a black cat might be
> >>>>>>>>>>>> some kind of dog.
> >>>>>>>>>>>>
> >>>>>>>>>>>> My whole system is now wrapped in 131K zip file as a
> >>>>>>>>>>>> Visual Studio project on a downloadable link.
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> No, maybe you need an actual programmer to look at your
> >>>>>>>>>>> logic.
> >>>>>>>>>>>
> >>>>>>>>>>> First, by definition correct emulation of a program will
> >>>>>>>>>>> match the behavior of the program.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> When you disagree with this precisely stated verified fact
> >>>>>>>>>> you are either a liar or incompetent:
> >>>>>>>>>>
> >>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>>>>
> >>>>>>>>>> When you disagree the the above precisely stated verified
> >>>>>>>>>> fact by changing its words and showing that the changed
> >>>>>>>>>> words are not true then between liar and incompetent you
> >>>>>>>>>> prove to be a liar.
> >>>>>>>>>
> >>>>>>>>> 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
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>
> >>>>>>> What I am saying is the following, no more, no less:
> >>>>>>>
> >>>>>>> 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
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> You are not committing to a criterion measure of correctness
> >>>>>> thus your claim is vague.
> >>>>>
> >>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
> >>>>> your H decides that it is non-halting.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
> >>>> because it gets stuck in an infinite loop, then Px(Px) doesn't
> >>>> Halt.
> >>>>
> >>>> Now, this H fails to be a decider, so can't be a counter example
> >>>> for a Halt Decider.
> >>>
> >>> If H is a valid halt decider (and by that I mean returns an answer
> >>> in finite time) then Px *will* always halt: it doesn't because
> >>> Olcott's H is not a valid halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Now that H has been very recently adapted to be a pure function of
> >> its inputs whenever it is invoked it always returns on finite time.
> >> H aborts its simulation of Px before Px invokes H.
> >>
> >> 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 its call to H is invoked.
> >
> > 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
> >
>
> So you are a mere bot now.

Click here to read the complete article

Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

<te6dnV78eYh_KTL_nZ2dnUU7_8zNnZ2d@giganews.com>

  copy mid

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

  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 18:44:34 -0500
Date: Sun, 19 Jun 2022 18:44: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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220620003212.000016ce@reddwarf.jmc>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220620003212.000016ce@reddwarf.jmc>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <te6dnV78eYh_KTL_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 496
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-rKZAf5m6oqXAWe6+40oB2mUf9nAR4YPSnBW1z2GbQ9WY3hsS32qyR6u99QO7J97cG56Q2tsztopLo31!AiAp4YYkzaFpHyya6h0HlmmUUdM//xriBkU1vagqGD5o2nGnNAusjpcONM7Qv1E+8GazXtAYgvJp
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: 26300
 by: olcott - Sun, 19 Jun 2022 23:44 UTC

On 6/19/2022 6:32 PM, Mr Flibble wrote:
> On Sun, 19 Jun 2022 18:25:33 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 6/19/2022 5:58 PM, Mr Flibble wrote:
>>> On Sun, 19 Jun 2022 18:53:36 -0400
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
>>>>> On Sun, 19 Jun 2022 17:16:03 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
>>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>>>>>> confirm that the correct and complete x86 emulation of
>>>>>>>>>>>>>> the input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>>>>>> instruction of Px.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That you can not understand this proves that you are not
>>>>>>>>>>>>>> a sufficiently technically competent software engineer on
>>>>>>>>>>>>>> this point. Very good COBOL programmers might never be
>>>>>>>>>>>>>> able to understand this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To anyone that writes or maintains operating systems
>>>>>>>>>>>>>> what I am claiming would be as easy to verify as first
>>>>>>>>>>>>>> grade arithmetic.
>>>>>>>>>>>>> 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
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Get an operating system programmer to explain to you that
>>>>>>>>>>>> the correct and complete x86 emulation of the input to
>>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
>>>>>>>>>>>> Px. *This is totally over your head*
>>>>>>>>>>>>
>>>>>>>>>>>> It is like I am saying that we know that black carts are
>>>>>>>>>>>> cats and you disagree saying the a black cat might be some
>>>>>>>>>>>> kind of dog.
>>>>>>>>>>>>
>>>>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>>>>>> Studio project on a downloadable link.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, maybe you need an actual programmer to look at your
>>>>>>>>>>> logic.
>>>>>>>>>>>
>>>>>>>>>>> First, by definition correct emulation of a program will
>>>>>>>>>>> match the behavior of the program.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When you disagree with this precisely stated verified fact
>>>>>>>>>> you are either a liar or incompetent:
>>>>>>>>>>
>>>>>>>>>> the correct and complete x86 emulation of the input to
>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
>>>>>>>>>>
>>>>>>>>>> When you disagree the the above precisely stated verified
>>>>>>>>>> fact by changing its words and showing that the changed
>>>>>>>>>> words are not true then between liar and incompetent you
>>>>>>>>>> prove to be a liar.
>>>>>>>>>
>>>>>>>>> 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
>>>>>>>>
>>>>>>>>
>>>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>> by H would never reach the "ret" instruction
>>>>>>>
>>>>>>> What I am saying is the following, no more, no less:
>>>>>>>
>>>>>>> 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
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> You are not committing to a criterion measure of correctness thus
>>>>>> your claim is vague.
>>>>>
>>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
>>>>> your H decides that it is non-halting.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
>>>> because it gets stuck in an infinite loop, then Px(Px) doesn't
>>>> Halt.
>>>>
>>>> Now, this H fails to be a decider, so can't be a counter example
>>>> for a Halt Decider.
>>>
>>> If H is a valid halt decider (and by that I mean returns an answer
>>> in finite time) then Px *will* always halt: it doesn't because
>>> Olcott's H is not a valid halt decider.
>>>
>>> /Flibble
>>>
>>
>> Now that H has been very recently adapted to be a pure function of
>> its inputs whenever it is invoked it always returns on finite time.
>> H aborts its simulation of Px before Px invokes H.
>>
>> 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 its call to H is invoked.
>
> To be a valid halt decider H must always return a value to its invoker,
> in this case Px; it doesn't so it isn't a valid halt decider.
>
> /Flibble
>


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

<20220620004957.00000826@reddwarf.jmc>

  copy mid

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

  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!fx06.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 [ liar or incompetent ]
Message-ID: <20220620004957.00000826@reddwarf.jmc>
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@giganews.com>
<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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com>
<s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc>
<QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220620003212.000016ce@reddwarf.jmc>
<te6dnV78eYh_KTL_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: 535
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sun, 19 Jun 2022 23:49:57 UTC
Date: Mon, 20 Jun 2022 00:49:57 +0100
X-Received-Bytes: 28247
 by: Mr Flibble - Sun, 19 Jun 2022 23:49 UTC

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

> On 6/19/2022 6:32 PM, Mr Flibble wrote:
> > On Sun, 19 Jun 2022 18:25:33 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 6/19/2022 5:58 PM, Mr Flibble wrote:
> >>> On Sun, 19 Jun 2022 18:53:36 -0400
> >>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>
> >>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
> >>>>> On Sun, 19 Jun 2022 17:16:03 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
> >>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
> >>>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
> >>>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
> >>>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
> >>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer
> >>>>>>>>>>>>>>> wrong saying Px doesn't halt. QED.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Every technically competent software engineer can
> >>>>>>>>>>>>>> easily confirm that the correct and complete x86
> >>>>>>>>>>>>>> emulation of the input to H(Px,Px) by H would never
> >>>>>>>>>>>>>> reach the "ret" instruction of Px.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> That you can not understand this proves that you are
> >>>>>>>>>>>>>> not a sufficiently technically competent software
> >>>>>>>>>>>>>> engineer on this point. Very good COBOL programmers
> >>>>>>>>>>>>>> might never be able to understand this.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> To anyone that writes or maintains operating systems
> >>>>>>>>>>>>>> what I am claiming would be as easy to verify as first
> >>>>>>>>>>>>>> grade arithmetic.
> >>>>>>>>>>>>> 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
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> Get an operating system programmer to explain to you that
> >>>>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction of
> >>>>>>>>>>>> Px. *This is totally over your head*
> >>>>>>>>>>>>
> >>>>>>>>>>>> It is like I am saying that we know that black carts are
> >>>>>>>>>>>> cats and you disagree saying the a black cat might be
> >>>>>>>>>>>> some kind of dog.
> >>>>>>>>>>>>
> >>>>>>>>>>>> My whole system is now wrapped in 131K zip file as a
> >>>>>>>>>>>> Visual Studio project on a downloadable link.
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> No, maybe you need an actual programmer to look at your
> >>>>>>>>>>> logic.
> >>>>>>>>>>>
> >>>>>>>>>>> First, by definition correct emulation of a program will
> >>>>>>>>>>> match the behavior of the program.
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> When you disagree with this precisely stated verified fact
> >>>>>>>>>> you are either a liar or incompetent:
> >>>>>>>>>>
> >>>>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>>>>
> >>>>>>>>>> When you disagree the the above precisely stated verified
> >>>>>>>>>> fact by changing its words and showing that the changed
> >>>>>>>>>> words are not true then between liar and incompetent you
> >>>>>>>>>> prove to be a liar.
> >>>>>>>>>
> >>>>>>>>> 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
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
> >>>>>>>> the correct and complete x86 emulation of the input to
> >>>>>>>> H(Px,Px) by H would never reach the "ret" instruction
> >>>>>>>
> >>>>>>> What I am saying is the following, no more, no less:
> >>>>>>>
> >>>>>>> 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
> >>>>>>>
> >>>>>>>
> >>>>>>
> >>>>>> You are not committing to a criterion measure of correctness
> >>>>>> thus your claim is vague.
> >>>>>
> >>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and
> >>>>> your H decides that it is non-halting.
> >>>>>
> >>>>> /Flibble
> >>>>>
> >>>>
> >>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return
> >>>> because it gets stuck in an infinite loop, then Px(Px) doesn't
> >>>> Halt.
> >>>>
> >>>> Now, this H fails to be a decider, so can't be a counter example
> >>>> for a Halt Decider.
> >>>
> >>> If H is a valid halt decider (and by that I mean returns an answer
> >>> in finite time) then Px *will* always halt: it doesn't because
> >>> Olcott's H is not a valid halt decider.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Now that H has been very recently adapted to be a pure function of
> >> its inputs whenever it is invoked it always returns on finite time.
> >> H aborts its simulation of Px before Px invokes H.
> >>
> >> 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 its call to H is invoked.
> >
> > To be a valid halt decider H must always return a value to its
> > invoker, in this case Px; it doesn't so it isn't a valid halt
> > decider.
> >
> > /Flibble
> >
>
> When a function is called in infinite recursion it merely never stops.
>
> When a halt decider is called in infinite recursion it essentially
> says https://www.youtube.com/watch?v=Z6EsNyIRG-g

Click here to read the complete article

Re: Halting Problem proof refutation is a tautology thus irrefutable [ liar or incompetent ]

<_mPrK.3629$El2.115@fx45.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 473
Message-ID: <_mPrK.3629$El2.115@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 20:41:30 -0400
X-Received-Bytes: 25468
 by: Richard Damon - Mon, 20 Jun 2022 00:41 UTC

On 6/19/22 7:25 PM, olcott wrote:
> On 6/19/2022 5:58 PM, Mr Flibble wrote:
>> On Sun, 19 Jun 2022 18:53:36 -0400
>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>> On 6/19/22 6:22 PM, Mr Flibble wrote:
>>>> On Sun, 19 Jun 2022 17:16:03 -0500
>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>> On 6/19/2022 4:46 PM, Mr Flibble wrote:
>>>>>> On Sun, 19 Jun 2022 16:23:17 -0500
>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>> On 6/19/2022 4:20 PM, Mr Flibble wrote:
>>>>>>>> On Sun, 19 Jun 2022 16:17:20 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>> On 6/19/2022 4:00 PM, Richard Damon wrote:
>>>>>>>>>> On 6/19/22 4:43 PM, olcott wrote:
>>>>>>>>>>> On 6/19/2022 3:31 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Sun, 19 Jun 2022 15:16:05 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 6/19/2022 3:08 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>> Px is defined to always halt; your H gets the answer wrong
>>>>>>>>>>>>>> saying Px doesn't halt. QED.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> Every technically competent software engineer can easily
>>>>>>>>>>>>> confirm that the correct and complete x86 emulation of the
>>>>>>>>>>>>> input to H(Px,Px) by H would never reach the "ret"
>>>>>>>>>>>>> instruction of Px.
>>>>>>>>>>>>>
>>>>>>>>>>>>> That you can not understand this proves that you are not a
>>>>>>>>>>>>> sufficiently technically competent software engineer on
>>>>>>>>>>>>> this point. Very good COBOL programmers might never be
>>>>>>>>>>>>> able to understand this.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To anyone that writes or maintains operating systems what I
>>>>>>>>>>>>> am claiming would be as easy to verify as first grade
>>>>>>>>>>>>> arithmetic.
>>>>>>>>>>>> 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
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Get an operating system programmer to explain to you that the
>>>>>>>>>>> correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>>>>> by H would never reach the "ret" instruction of Px. *This is
>>>>>>>>>>> totally over your head*
>>>>>>>>>>>
>>>>>>>>>>> It is like I am saying that we know that black carts are cats
>>>>>>>>>>> and you disagree saying the a black cat might be some kind of
>>>>>>>>>>> dog.
>>>>>>>>>>>
>>>>>>>>>>> My whole system is now wrapped in 131K zip file as a Visual
>>>>>>>>>>> Studio project on a downloadable link.
>>>>>>>>>>
>>>>>>>>>> No, maybe you need an actual programmer to look at your logic.
>>>>>>>>>>
>>>>>>>>>> First, by definition correct emulation of a program will match
>>>>>>>>>> the behavior of the program.
>>>>>>>>>
>>>>>>>>> When you disagree with this precisely stated verified fact you
>>>>>>>>> are either a liar or incompetent:
>>>>>>>>>
>>>>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>>>> by H would never reach the "ret" instruction
>>>>>>>>>
>>>>>>>>> When you disagree the the above precisely stated verified fact
>>>>>>>>> by changing its words and showing that the changed words are
>>>>>>>>> not true then between liar and incompetent you prove to be a
>>>>>>>>> liar.
>>>>>>>> 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
>>>>>>>
>>>>>>>
>>>>>>> DOES THAT MEAN THAT YOU ARE SAYING THAT THIS IS FALSE?
>>>>>>> the correct and complete x86 emulation of the input to H(Px,Px)
>>>>>>> by H would never reach the "ret" instruction
>>>>>>
>>>>>> What I am saying is the following, no more, no less:
>>>>>>
>>>>>> 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
>>>>>
>>>>> You are not committing to a criterion measure of correctness thus
>>>>> your claim is vague.
>>>> Vague? My "claim" is crystal clear: Px should ALWAYS HALT and your H
>>>> decides that it is non-halting.
>>>>
>>>> /Flibble
>>>
>>> Flibble, Px doesn't "Always" Halt. If H(Px,Px) doesn't return because
>>> it gets stuck in an infinite loop, then Px(Px) doesn't Halt.
>>>
>>> Now, this H fails to be a decider, so can't be a counter example for
>>> a Halt Decider.
>>
>> If H is a valid halt decider (and by that I mean returns an answer in
>> finite time) then Px *will* always halt: it doesn't because Olcott's H
>> is not a valid halt decider.
>>
>> /Flibble
>>
>
> Now that H has been very recently adapted to be a pure function of its
> inputs whenever it is invoked it always returns on finite time.
> H aborts its simulation of Px before Px invokes H.
>


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

<PqPrK.91246$ssF.14075@fx14.iad>

  copy mid

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

  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!fx14.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
[ liar or incompetent ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <d8-dnTlDr8xgoTL_nZ2dnUU7_83NnZ2d@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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <s7MrK.305$Eh2.78@fx41.iad>
<K4adnWJPQ6H9DzL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619222001.00006585@reddwarf.jmc>
<aeqdnfOXoMVYDjL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619224657.00005e40@reddwarf.jmc>
<fd6dndI6Zq--PTL_nZ2dnUU7_81g4p2d@giganews.com>
<20220619232200.00004368@reddwarf.jmc> <QNNrK.139616$X_i.21563@fx18.iad>
<20220619235825.000032bf@reddwarf.jmc>
<pcednU2mH_jwLTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220620003212.000016ce@reddwarf.jmc>
<te6dnV78eYh_KTL_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <te6dnV78eYh_KTL_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 19
Message-ID: <PqPrK.91246$ssF.14075@fx14.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 20:45:35 -0400
X-Received-Bytes: 2498
 by: Richard Damon - Mon, 20 Jun 2022 00:45 UTC

On 6/19/22 7:44 PM, olcott wrote:
>>
>
> When a function is called in infinite recursion it merely never stops.
>
> When a halt decider is called in infinite recursion it essentially says
> https://www.youtube.com/watch?v=Z6EsNyIRG-g

Whixh means that the function used the halt decider doesn't get into the
infinite loop either, BECAUSE the Halt decider stopped the loop.

Your problem is your H thinks it will but then it doesn't so it just was
incorrect about the behavior.

And, there is no special case in the definitions that allow it to get a
pass for this case.

FAIL.

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

<t8olus$956$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ strawman ]
Date: Sun, 19 Jun 2022 20:27:40 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 25
Message-ID: <t8olus$956$1@dont-email.me>
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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <t8o6eb$h5l$1@dont-email.me>
<fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 20 Jun 2022 02:27:40 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="dc78a7000d00621f682109192d8b85a1";
logging-data="9382"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19uB0J8bZkmFnc/cOwGYsn4"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:91.0)
Gecko/20100101 Thunderbird/91.9.1
Cancel-Lock: sha1:Q1OlvQdDmfN6YMgQ7wluo8NOZoI=
In-Reply-To: <fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 20 Jun 2022 02:27 UTC

On 2022-06-19 16:18, olcott wrote:
> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>> On 2022-06-19 14:43, olcott wrote:
>>
>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>> project on a downloadable link.
>>
>> I see no link anywhere.
>>
>> André
>>
>
> Are you sure maybe you didn't look hard enough?
> Maybe there is an invisible link between "131K" and "zip"

If you posted it somewhere, wouldn't it be easier to simply repost the
link rather than make snide comments?

Or if you don't intend to post the link, then say so.

André

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

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

<z2RrK.187832$70j.68307@fx16.iad>

  copy mid

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

  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!fx16.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
[ 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>
<5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <t8o6eb$h5l$1@dont-email.me>
<fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 20
Message-ID: <z2RrK.187832$70j.68307@fx16.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 22:36:15 -0400
X-Received-Bytes: 2394
 by: Richard Damon - Mon, 20 Jun 2022 02:36 UTC

On 6/19/22 6:18 PM, olcott wrote:
> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>> On 2022-06-19 14:43, olcott wrote:
>>
>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>> project on a downloadable link.
>>
>> I see no link anywhere.
>>
>> André
>>
>
> Are you sure maybe you didn't look hard enough?
> Maybe there is an invisible link between "131K" and "zip"
>

Except that there isn't one. Note Content-type Text/Plain doesn't have a
way to "Hide" links.

My guess is this is just your normal less-than-truthful sort of comment.

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

<_bidnY-lVYuCezL_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

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

  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 22:14:39 -0500
Date: Sun, 19 Jun 2022 22:14:38 -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>
<5YudnR0PwMnqHDL_nZ2dnUU7_83NnZ2d@giganews.com>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <t8o6eb$h5l$1@dont-email.me>
<fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com> <t8olus$956$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t8olus$956$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_bidnY-lVYuCezL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 59
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Ti1yj0sFBfpobcLUndcEKwEEQ6YB6tWPA8GMr60WJTYcSEPSmLVx/KwBka8Bd/9qBqqx9GN71g4W9bj!xhJuJm+NmiEz0EAc+HaI6eGsBAIDxN956rsucRBQPjBFkmDz+9xpgc1cS1ptiFychnf4Hevzks8u
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: 4550
 by: olcott - Mon, 20 Jun 2022 03:14 UTC

On 6/19/2022 9:27 PM, André G. Isaak wrote:
> On 2022-06-19 16:18, olcott wrote:
>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>> On 2022-06-19 14:43, olcott wrote:
>>>
>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>> project on a downloadable link.
>>>
>>> I see no link anywhere.
>>>
>>> André
>>>
>>
>> Are you sure maybe you didn't look hard enough?
>> Maybe there is an invisible link between "131K" and "zip"
>
> If you posted it somewhere, wouldn't it be easier to simply repost the
> link rather than make snide comments?
>
> Or if you don't intend to post the link, then say so.
>
> André
>

I do not intend to post the link very soon.
Because reviewers here have been so consistently disparaging of my work
they will be last in line to be able to have access to this code.

When I boiled my claims down to two easily verified facts of software
engineering and everyone consistently still disagreed then I knew that
none of my reviewers were both sufficiently technically competent and
honest.

It is a very 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. Only one reviewer out of 100 reviewers in a dozen
different forums over the period of a year would acknowledge that.

The x86 emulator code is immaculate because I was very cautious in my
slight changes to keep it very clean. H is the one halt decider that has
all of its code quite clean and finally a pure function of its inputs.
The x86utm operating system code is very reliable yet quite messy.

At this point I have provided enough evidence that reasonable people
would conclude that all of my claims of having actual code have been
sufficiently proven. I decided that posting this code as a Google Drive
downloadable link to a complete Visual Studio project is the way to go.

The solution is defined so that immediately after the build the halt
decider can be directly run from inside Visual Studio. The halt decider
file itself can be edited to run different halt deciders on a small
library of sample inputs. Right out of the box H(P,P) is executed.

--
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 [ strawman ]

<t8opp2$s0t$1@dont-email.me>

  copy mid

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

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: agis...@gm.invalid (André G. Isaak)
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
Subject: Re: Halting Problem proof refutation is a tautology thus irrefutable
[ strawman ]
Date: Sun, 19 Jun 2022 21:32:50 -0600
Organization: Christians and Atheists United Against Creeping Agnosticism
Lines: 35
Message-ID: <t8opp2$s0t$1@dont-email.me>
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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <t8o6eb$h5l$1@dont-email.me>
<fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com> <t8olus$956$1@dont-email.me>
<_bidnY-lVYuCezL_nZ2dnUU7_83NnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Mon, 20 Jun 2022 03:32:50 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="4edd90bf18c8c0611bc548cda38fc0e4";
logging-data="28701"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+sdn8ZrSJX8uzrLTVbIQWi"
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:91.0)
Gecko/20100101 Thunderbird/91.9.1
Cancel-Lock: sha1:6+u+meGRRVdLU7aOcagiLGOTE4M=
In-Reply-To: <_bidnY-lVYuCezL_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Language: en-US
 by: André G. Isaak - Mon, 20 Jun 2022 03:32 UTC

On 2022-06-19 21:14, olcott wrote:
> On 6/19/2022 9:27 PM, André G. Isaak wrote:
>> On 2022-06-19 16:18, olcott wrote:
>>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>>> On 2022-06-19 14:43, olcott wrote:
>>>>
>>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>>> project on a downloadable link.
>>>>
>>>> I see no link anywhere.
>>>>
>>>> André
>>>>
>>>
>>> Are you sure maybe you didn't look hard enough?
>>> Maybe there is an invisible link between "131K" and "zip"
>>
>> If you posted it somewhere, wouldn't it be easier to simply repost the
>> link rather than make snide comments?
>>
>> Or if you don't intend to post the link, then say so.
>>
>> André
>>
>
> I do not intend to post the link very soon.

So then why bother mentioning it at all?

André

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

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

<JY6dnaTAV8GUcjL_nZ2dnUU7_83NnZ2d@giganews.com>

  copy mid

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

  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 22:52:41 -0500
Date: Sun, 19 Jun 2022 22:52:40 -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>
<--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>
<20220619210812.00003001@reddwarf.jmc>
<6N6dnYHnFNCYGTL_nZ2dnUU7_8zNnZ2d@giganews.com>
<20220619213137.00004b36@reddwarf.jmc>
<LJydne9Uae7JFzL_nZ2dnUU7_83NnZ2d@giganews.com> <t8o6eb$h5l$1@dont-email.me>
<fd6dnc06Zq8jPTL_nZ2dnUU7_81g4p2d@giganews.com> <t8olus$956$1@dont-email.me>
<_bidnY-lVYuCezL_nZ2dnUU7_83NnZ2d@giganews.com> <t8opp2$s0t$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t8opp2$s0t$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <JY6dnaTAV8GUcjL_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 55
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-6nZhK1rWvooiUDFV65GBaY8RnMisF5AxgvvZeP3x+K3YAKgWaO76H7SdxkVmyIDVNKvB+Y9Y5z27jLO!fEgTqrMvcTuEk4BN7oDtypUZZCgRmDDnlsIlbRZmYYTlEtmpnCGSq0PDMzs7hiydHTeodVuOhYVv
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: 3873
 by: olcott - Mon, 20 Jun 2022 03:52 UTC

On 6/19/2022 10:32 PM, André G. Isaak wrote:
> On 2022-06-19 21:14, olcott wrote:
>> On 6/19/2022 9:27 PM, André G. Isaak wrote:
>>> On 2022-06-19 16:18, olcott wrote:
>>>> On 6/19/2022 5:02 PM, André G. Isaak wrote:
>>>>> On 2022-06-19 14:43, olcott wrote:
>>>>>
>>>>>> My whole system is now wrapped in 131K zip file as a Visual Studio
>>>>>> project on a downloadable link.
>>>>>
>>>>> I see no link anywhere.
>>>>>
>>>>> André
>>>>>
>>>>
>>>> Are you sure maybe you didn't look hard enough?
>>>> Maybe there is an invisible link between "131K" and "zip"
>>>
>>> If you posted it somewhere, wouldn't it be easier to simply repost
>>> the link rather than make snide comments?
>>>
>>> Or if you don't intend to post the link, then say so.
>>>
>>> André
>>>
>>
>> I do not intend to post the link very soon.
>
> So then why bother mentioning it at all?
>
> André
>
>

That I have all of the code fully operational in a single 131K zipped
Visual studio project is a key milestone.

On 3/14/2017 9:05 AM, peteolcott wrote: in comp.theory
[Solution to one instance of the Halting Problem]

Is when I first showed that a simulating halt decider could correctly
determine that the conventional input to the halting problem proofs
could be correctly decided as non-halting on the basis that they specify
infinitely nested simulation to every simulating halt decider.

It has been an average of at least full time work on this project ever
since.

--
Copyright 2022 Pete Olcott

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

Pages:1234
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor