Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

No line available at 300 baud.


devel / comp.theory / Re: On Strachey [ How nuts is that? ]

SubjectAuthor
* On StracheyMr Flibble
+* On Stracheyolcott
|`* On StracheyMr Flibble
| `* On Stracheyolcott
|  `* On StracheyMr Flibble
|   `* On Stracheyolcott
|    `* On StracheyBen
|     +* On Stracheyolcott
|     |`- On StracheyBen
|     `* On StracheyMr Flibble
|      `* On StracheyBen
|       +* On StracheyJeff Barnett
|       |`- On StracheyMr Flibble
|       `* On StracheyMr Flibble
|        +* On Stracheyolcott
|        |`* On StracheyBen
|        | `* On Stracheyolcott
|        |  `* On StracheyBen
|        |   `* On Stracheyolcott
|        |    +- On StracheyRichard Damon
|        |    `* On StracheyBen
|        |     `* On Strachey [ How nuts is that? ]olcott
|        |      +* On Strachey [ How nuts is that? ]Dennis Bush
|        |      |`* On Strachey [ How nuts is that? ]olcott
|        |      | +* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |`* On Strachey [ How nuts is that? ]olcott
|        |      | | `* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |  `* On Strachey [ How nuts is that? ]olcott
|        |      | |   `* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |    `* On Strachey [ How nuts is that? ]olcott
|        |      | |     +* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     |`* On Strachey [ How nuts is that? ]olcott
|        |      | |     | +* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | |`* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | +* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | |+- On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |`* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | | `* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |  `* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | |   +- On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |   `* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | |    +* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    |+* On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    ||`* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    || `* On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    ||  `* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    ||   `* On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    ||    `* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    ||     `* On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    ||      `* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    ||       +* On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    ||       |`* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    ||       | `* On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    ||       |  `* On Strachey [ How nuts is that? ][ proof that I am correct ]olcott
|        |      | |     | | |    ||       |   `- On Strachey [ How nuts is that? ][ proof that I am correct ]Richard Damon
|        |      | |     | | |    ||       `- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     | | |    |+- On Strachey [ How nuts is that? ]wij
|        |      | |     | | |    |+* On Strachey [ How nuts is that? ]Jeff Barnett
|        |      | |     | | |    ||+* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    |||+- On Strachey [ How nuts is that? ]Jeff Barnett
|        |      | |     | | |    |||`- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     | | |    ||`* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |    || `- On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | |    |`- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     | | |    `* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | |     +* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |     |`- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     | | |     `* On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | |      +* On Strachey [ How nuts is that? ]olcott
|        |      | |     | | |      |`- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     | | |      `- On Strachey [ How nuts is that? ]Dennis Bush
|        |      | |     | | `- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     | `- On Strachey [ How nuts is that? ]Richard Damon
|        |      | |     `- On Strachey [ How nuts is that? ]Richard Damon
|        |      | +- On Strachey [ How nuts is that? ]Richard Damon
|        |      | `- On Strachey [ How nuts is that? ]Richard Damon
|        |      `- On Strachey [ How nuts is that? ]Ben
|        `- On StracheyBen
`* On StracheyMikko
 +* On StracheyMr Flibble
 |+* On StracheyMikko
 ||`- On Stracheyolcott
 |`- On Stracheyolcott
 `- On Stracheyolcott

Pages:1234
Re: On Strachey [ How nuts is that? ]

<JMheK.2246$wYy9.14@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!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.9.0
Subject: Re: On Strachey [ How nuts is that? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220505204551.00001f5f@reddwarf.jmc>
<8599ac1b-30c1-49b8-ad8a-0811b3d581b3n@googlegroups.com>
<e-CdnRRLy4B5ter_nZ2dnUU7_83NnZ2d@giganews.com>
<d5dd6404-05b7-4fa4-add5-87cc7d22e54cn@googlegroups.com>
<Rv-dndhesPYhruT_nZ2dnUU7_83NnZ2d@giganews.com>
<83cf00e9-83c4-4be0-8874-9c9d042947a3n@googlegroups.com>
<SdudnWkwTth8puT_nZ2dnUU7_83NnZ2d@giganews.com>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com>
<44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com>
<93f7e011-d1b0-4cb5-87bb-2e991b138065n@googlegroups.com>
<bIidnejrQoM6CeT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <bIidnejrQoM6CeT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 260
Message-ID: <JMheK.2246$wYy9.14@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: Mon, 9 May 2022 19:50:03 -0400
X-Received-Bytes: 14351
 by: Richard Damon - Mon, 9 May 2022 23:50 UTC

On 5/9/22 6:24 PM, olcott wrote:
> On 5/9/2022 4:30 PM, Dennis Bush wrote:
>> On Monday, May 9, 2022 at 5:20:02 PM UTC-4, olcott wrote:
>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:
>>>> On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote:
>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:
>>>>>> On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote:
>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:
>>>>>>>> On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote:
>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:
>>>>>>>>>> On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote:
>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/9/2022 11:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/7/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 5/7/2022 8:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/7/2022 7:48 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 6:35 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 5:47 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 8:07 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 7:11 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting theorem follows, trivially, from
>>>>>>>>>>>>>>>>>>>>>>>>>>>> lots of simpler theorems,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of which have you bothered to read. In
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Linz, the theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> presented as a corollary of a simpler
>>>>>>>>>>>>>>>>>>>>>>>>>>>> theorem in chapter 11.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> 11.3, 11.4, and 11.5. I will look at them.
>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the change of heart?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> There is enough progress now that I don't have
>>>>>>>>>>>>>>>>>>>>>>>>> to have an absolutely
>>>>>>>>>>>>>>>>>>>>>>>>> single-minded focus.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Progress?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS AN EASILY VERIFIABLE FACT:
>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine code of P as
>>>>>>>>>>>>>>>>>>>>>>>>> input parameters and
>>>>>>>>>>>>>>>>>>>>>>>>> correctly compute the mapping from this input
>>>>>>>>>>>>>>>>>>>>>>>>> to an accept ore reject
>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that
>>>>>>>>>>>>>>>>>>>>>>>>> these inputs actually
>>>>>>>>>>>>>>>>>>>>>>>>> specify.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But H does not decide the halting of P(P).
>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M)
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>> return (N + M);
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is not supposed to in the same way that
>>>>>>>>>>>>>>>>>>>>>>> sum(3,4) is not supposed to
>>>>>>>>>>>>>>>>>>>>>>> provide the sum of (5,7).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Why is this so difficult for you?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You know that if anyone insisted that sum(3,4)
>>>>>>>>>>>>>>>>>>>>>>> must return the value of
>>>>>>>>>>>>>>>>>>>>>>> sum(5,7) that they are wrong.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Then why do you insist that H(P,P) must return the
>>>>>>>>>>>>>>>>>>>>>> value of H(Pn,Pn)?
>>>>>>>>>>>>>>>>>>>>> The definition of decider requires it to based its
>>>>>>>>>>>>>>>>>>>>> decision on whatever
>>>>>>>>>>>>>>>>>>>>> its input specifies.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Which in the case of H(P,P) is *defined* to be P(P)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> In this case it is the same as if {dogs} are defined
>>>>>>>>>>>>>>>>>>> to be {cats}.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So no rebuttal, just a bad analogy.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Both H(P,P) and H1(P,P) use this exact literal byte
>>>>>>>>>>>>>>>>>>>>> string as their
>>>>>>>>>>>>>>>>>>>>> input therefore it seems enormously dishonest of
>>>>>>>>>>>>>>>>>>>>> you to refer to the
>>>>>>>>>>>>>>>>>>>>> same literal string using different subscripts
>>>>>>>>>>>>>>>>>>>>> indicating a difference
>>>>>>>>>>>>>>>>>>>>> of the same string with itself.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> What I was saying is that you think that H sees
>>>>>>>>>>>>>>>>>>>> infinite simulation which only exists in Pn(Pn)
>>>>>>>>>>>>>>>>>>> All that crazy bullshit about subscripted names of
>>>>>>>>>>>>>>>>>>> subscripts is
>>>>>>>>>>>>>>>>>>> extremely deceptive
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, just the opposite. It makes it clear *exactly*
>>>>>>>>>>>>>>>>>> which computation we're talking about, so it prevents
>>>>>>>>>>>>>>>>>> YOU from being deceptive.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am ONLY referring to this literal string:
>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>> as x86 machine code correctly simulated by H(P,P) and
>>>>>>>>>>>>>>>>>>> H1(P,P).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No you're not. You're also referring to the literal
>>>>>>>>>>>>>>>>>> string which is the fixed code of H which aborts as
>>>>>>>>>>>>>>>>>> that is part of the program P. So from here on, we'll
>>>>>>>>>>>>>>>>>> refer to H as Ha and P as Pa to make that point clear.
>>>>>>>>>>>>>>>>> I am only referring to this literal string:
>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> as an input to H(P,P) and H1(P,P). It is 100% perfectly
>>>>>>>>>>>>>>>>> concrete
>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>> utterly impervious to even extremely well-crafted
>>>>>>>>>>>>>>>>> attempts at deception
>>>>>>>>>>>>>>>>> through the strawman error. Any attempt to get around
>>>>>>>>>>>>>>>>> this will be
>>>>>>>>>>>>>>>>> construed as (and labeled) a bald-faced lie by a
>>>>>>>>>>>>>>>>> bald-faced liar.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That string is 100% NOT concrete because it doesn't
>>>>>>>>>>>>>>>> specify the function that it is calling.
>>>>>>>>>>>>>>> I did not freaking say that this finite string specifies
>>>>>>>>>>>>>>> every freaking
>>>>>>>>>>>>>>> detail of the whole freaking system nitwit. This finite
>>>>>>>>>>>>>>> string as x86
>>>>>>>>>>>>>>> code specifies every one of its own bytes.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Not the whole system, just the computation to be decided
>>>>>>>>>>>>>> on, and that computation includes the FIXED code of H that
>>>>>>>>>>>>>> aborts its simulation, i.e. Ha.
>>>>>>>>>>>>> Thee is no Pa, Pb, Pc, there is only this P:
>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>
>>>>>>>>>>>> So if that's enough information to decide on, then tell me
>>>>>>>>>>>> if this halts:
>>>>>>>>>>>>
>>>>>>>>>>>> void F()
>>>>>>>>>>>> {
>>>>>>>>>>>> X()
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>> I am only talking about H(P,P) and H1(P,P) where P is this
>>>>>>>>>>> literal
>>>>>>>>>>> string as x86 machine language:
>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>
>>>>>>>>>> Again, not a complete computation, so not enough information
>>>>>>>>>> to decide on. You seem to think that all "P" constructs are
>>>>>>>>>> the same no matter how different the H it is built on is.
>>>>>>>>> Within the context of my paper it is a complete computation for
>>>>>>>>> H(P,P).
>>>>>>>>> I am updating the paper to include H1(P,P).
>>>>>>>>
>>>>>>>> So if H is the *specific* decider that can detect infinite
>>>>>>>> simulation in Pn(Pn), then we'll refer to it as Ha to clarify
>>>>>>>> that point, and we'll refer to the P that calls it as Pa to
>>>>>>>> clarify.
>>>>>>>>
>>>>>>> I am talking about the literal string of "H" being applied to this
>>>>>>> literal string:
>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>
>>>>>>> and
>>>>>>>
>>>>>>> The literal string of "H1" being applied to this literal string:
>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>
>>>>>> And to complete the computation being evaluated, what is the
>>>>>> *exact*, FIXED algorithm of H? If it is Ha, then Ha(Pa,Pa) ==
>>>>>> false is wrong as demonstrated by Hb(Pa,Pa) == true.
>>>>>>
>>>>>> If H is using some other algorithm, then specify the *exact*
>>>>>> algorithm.
>>>>> H and H1 are both literal byte strings that emulate their literal byte
>>>>> string input in pure x86 emulation mode until the behavior of this
>>>>> emulated literal byte string input shows that it would never reach its
>>>>> own final state (0xc3 ret instruction).
>>>>
>>>> So in other words, the fixed algorithm of H looks for what it thinks
>>>> is infinite simulation. So H is Ha, which means P is Pa.
>>>>
>>>> Hb can then be constructed to simulate for k more steps than Ha and
>>>> calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>> Begin Local Halt Decider Simulation
>>> machine stack stack machine assembly
>>> address address data code language
>>> ======== ======== ======== ========= =============
>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> The fact that P calls the same function from its same machine address
>>> with identical input parameters conclusively proves that P is stuck in
>>> infinite recursion.
>>
>> First, it's not recursion, infinite or otherwise.  It's nested
>> simulation, and the conditions that are part of the simulation are
>> relevant.
>
> Infinitely nested simulation matches the infinite recursion infinite
> behavior pattern. If H verified that the function that P calls is itself
> then H could distinguish the difference. It need not do this infinite
> behavior is all that it needs to know.
>
>>
>> And it's not infinite nested simulation because Hb simulates Pa past
>> the point where Ha aborts, sees that the embedded copy of Ha aborts,
>> and sees Pa halt.  So Ha is wrong.
>
> This is factually incorrect. The outermost H sees the infinite behavior
> pattern first and knows that if it doesn't abort the simulation of its
> input after a fixed number of simulations that the input will never
> stop. I set this fixed number at the minimum of 2.
>
>


Click here to read the complete article
Re: On Strachey [ How nuts is that? ]

<nPheK.2247$wYy9.45@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.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.9.0
Subject: Re: On Strachey [ How nuts is that? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220505204551.00001f5f@reddwarf.jmc>
<d5dd6404-05b7-4fa4-add5-87cc7d22e54cn@googlegroups.com>
<Rv-dndhesPYhruT_nZ2dnUU7_83NnZ2d@giganews.com>
<83cf00e9-83c4-4be0-8874-9c9d042947a3n@googlegroups.com>
<SdudnWkwTth8puT_nZ2dnUU7_83NnZ2d@giganews.com>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com>
<44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com>
<93f7e011-d1b0-4cb5-87bb-2e991b138065n@googlegroups.com>
<bIidnejrQoM6CeT_nZ2dnUU7_8zNnZ2d@giganews.com>
<5027eb52-276e-4d17-b7e1-cbff2eadf196n@googlegroups.com>
<_PmdnY4bxv-lPeT_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_PmdnY4bxv-lPeT_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 278
Message-ID: <nPheK.2247$wYy9.45@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: Mon, 9 May 2022 19:52:52 -0400
X-Received-Bytes: 15890
 by: Richard Damon - Mon, 9 May 2022 23:52 UTC

On 5/9/22 7:13 PM, olcott wrote:
> On 5/9/2022 5:56 PM, Dennis Bush wrote:
>> On Monday, May 9, 2022 at 6:24:46 PM UTC-4, olcott wrote:
>>> On 5/9/2022 4:30 PM, Dennis Bush wrote:
>>>> On Monday, May 9, 2022 at 5:20:02 PM UTC-4, olcott wrote:
>>>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:
>>>>>> On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote:
>>>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:
>>>>>>>> On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote:
>>>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:
>>>>>>>>>> On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:
>>>>>>>>>>>> On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/9/2022 11:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/7/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/7/2022 8:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 7:48 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 6:35 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 5:47 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 8:07 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 7:11 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting theorem follows, trivially,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> from lots of simpler theorems,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of which have you bothered to read.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In Linz, the theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presented as a corollary of a simpler
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theorem in chapter 11.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11.3, 11.4, and 11.5. I will look at them.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the change of heart?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> There is enough progress now that I don't
>>>>>>>>>>>>>>>>>>>>>>>>>>> have to have an absolutely
>>>>>>>>>>>>>>>>>>>>>>>>>>> single-minded focus.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Progress?
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS AN EASILY VERIFIABLE FACT:
>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine code of P
>>>>>>>>>>>>>>>>>>>>>>>>>>> as input parameters and
>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly compute the mapping from this input
>>>>>>>>>>>>>>>>>>>>>>>>>>> to an accept ore reject
>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> that these inputs actually
>>>>>>>>>>>>>>>>>>>>>>>>>>> specify.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not decide the halting of P(P).
>>>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>> return (N + M);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is not supposed to in the same way that
>>>>>>>>>>>>>>>>>>>>>>>>> sum(3,4) is not supposed to
>>>>>>>>>>>>>>>>>>>>>>>>> provide the sum of (5,7).
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Why is this so difficult for you?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You know that if anyone insisted that sum(3,4)
>>>>>>>>>>>>>>>>>>>>>>>>> must return the value of
>>>>>>>>>>>>>>>>>>>>>>>>> sum(5,7) that they are wrong.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Then why do you insist that H(P,P) must return
>>>>>>>>>>>>>>>>>>>>>>>> the value of H(Pn,Pn)?
>>>>>>>>>>>>>>>>>>>>>>> The definition of decider requires it to based
>>>>>>>>>>>>>>>>>>>>>>> its decision on whatever
>>>>>>>>>>>>>>>>>>>>>>> its input specifies.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Which in the case of H(P,P) is *defined* to be P(P)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> In this case it is the same as if {dogs} are
>>>>>>>>>>>>>>>>>>>>> defined to be {cats}.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So no rebuttal, just a bad analogy.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Both H(P,P) and H1(P,P) use this exact literal
>>>>>>>>>>>>>>>>>>>>>>> byte string as their
>>>>>>>>>>>>>>>>>>>>>>> input therefore it seems enormously dishonest of
>>>>>>>>>>>>>>>>>>>>>>> you to refer to the
>>>>>>>>>>>>>>>>>>>>>>> same literal string using different subscripts
>>>>>>>>>>>>>>>>>>>>>>> indicating a difference
>>>>>>>>>>>>>>>>>>>>>>> of the same string with itself.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> What I was saying is that you think that H sees
>>>>>>>>>>>>>>>>>>>>>> infinite simulation which only exists in Pn(Pn)
>>>>>>>>>>>>>>>>>>>>> All that crazy bullshit about subscripted names of
>>>>>>>>>>>>>>>>>>>>> subscripts is
>>>>>>>>>>>>>>>>>>>>> extremely deceptive
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No, just the opposite. It makes it clear *exactly*
>>>>>>>>>>>>>>>>>>>> which computation we're talking about, so it
>>>>>>>>>>>>>>>>>>>> prevents YOU from being deceptive.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am ONLY referring to this literal string:
>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>> as x86 machine code correctly simulated by H(P,P)
>>>>>>>>>>>>>>>>>>>>> and H1(P,P).
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> No you're not. You're also referring to the literal
>>>>>>>>>>>>>>>>>>>> string which is the fixed code of H which aborts as
>>>>>>>>>>>>>>>>>>>> that is part of the program P. So from here on,
>>>>>>>>>>>>>>>>>>>> we'll refer to H as Ha and P as Pa to make that
>>>>>>>>>>>>>>>>>>>> point clear.
>>>>>>>>>>>>>>>>>>> I am only referring to this literal string:
>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> as an input to H(P,P) and H1(P,P). It is 100%
>>>>>>>>>>>>>>>>>>> perfectly concrete
>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>> utterly impervious to even extremely well-crafted
>>>>>>>>>>>>>>>>>>> attempts at deception
>>>>>>>>>>>>>>>>>>> through the strawman error. Any attempt to get around
>>>>>>>>>>>>>>>>>>> this will be
>>>>>>>>>>>>>>>>>>> construed as (and labeled) a bald-faced lie by a
>>>>>>>>>>>>>>>>>>> bald-faced liar.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That string is 100% NOT concrete because it doesn't
>>>>>>>>>>>>>>>>>> specify the function that it is calling.
>>>>>>>>>>>>>>>>> I did not freaking say that this finite string
>>>>>>>>>>>>>>>>> specifies every freaking
>>>>>>>>>>>>>>>>> detail of the whole freaking system nitwit. This finite
>>>>>>>>>>>>>>>>> string as x86
>>>>>>>>>>>>>>>>> code specifies every one of its own bytes.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Not the whole system, just the computation to be decided
>>>>>>>>>>>>>>>> on, and that computation includes the FIXED code of H
>>>>>>>>>>>>>>>> that aborts its simulation, i.e. Ha.
>>>>>>>>>>>>>>> Thee is no Pa, Pb, Pc, there is only this P:
>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So if that's enough information to decide on, then tell me
>>>>>>>>>>>>>> if this halts:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void F()
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>> X()
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I am only talking about H(P,P) and H1(P,P) where P is this
>>>>>>>>>>>>> literal
>>>>>>>>>>>>> string as x86 machine language:
>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>
>>>>>>>>>>>> Again, not a complete computation, so not enough information
>>>>>>>>>>>> to decide on. You seem to think that all "P" constructs are
>>>>>>>>>>>> the same no matter how different the H it is built on is.
>>>>>>>>>>> Within the context of my paper it is a complete computation
>>>>>>>>>>> for H(P,P).
>>>>>>>>>>> I am updating the paper to include H1(P,P).
>>>>>>>>>>
>>>>>>>>>> So if H is the *specific* decider that can detect infinite
>>>>>>>>>> simulation in Pn(Pn), then we'll refer to it as Ha to clarify
>>>>>>>>>> that point, and we'll refer to the P that calls it as Pa to
>>>>>>>>>> clarify.
>>>>>>>>>>
>>>>>>>>> I am talking about the literal string of "H" being applied to this
>>>>>>>>> literal string:
>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>
>>>>>>>>> and
>>>>>>>>>
>>>>>>>>> The literal string of "H1" being applied to this literal string:
>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>
>>>>>>>> And to complete the computation being evaluated, what is the
>>>>>>>> *exact*, FIXED algorithm of H? If it is Ha, then Ha(Pa,Pa) ==
>>>>>>>> false is wrong as demonstrated by Hb(Pa,Pa) == true.
>>>>>>>>
>>>>>>>> If H is using some other algorithm, then specify the *exact*
>>>>>>>> algorithm.
>>>>>>> H and H1 are both literal byte strings that emulate their literal
>>>>>>> byte
>>>>>>> string input in pure x86 emulation mode until the behavior of this
>>>>>>> emulated literal byte string input shows that it would never
>>>>>>> reach its
>>>>>>> own final state (0xc3 ret instruction).
>>>>>>
>>>>>> So in other words, the fixed algorithm of H looks for what it
>>>>>> thinks is infinite simulation. So H is Ha, which means P is Pa.
>>>>>>
>>>>>> Hb can then be constructed to simulate for k more steps than Ha
>>>>>> and calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>>>> Begin Local Halt Decider Simulation
>>>>> machine stack stack machine assembly
>>>>> address address data code language
>>>>> ======== ======== ======== ========= =============
>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>
>>>>> The fact that P calls the same function from its same machine address
>>>>> with identical input parameters conclusively proves that P is stuck in
>>>>> infinite recursion.
>>>>
>>>> First, it's not recursion, infinite or otherwise. It's nested
>>>> simulation, and the conditions that are part of the simulation are
>>>> relevant.
>>> Infinitely nested simulation matches the infinite recursion infinite
>>> behavior pattern. If H verified that the function that P calls is itself
>>> then H could distinguish the difference. It need not do this infinite
>>> behavior is all that it needs to know.
>>
>> Pa doesn't call itself.  It calls Ha which simulates Pa, and the
>> simulation performed by Ha *will* abort.
>>
>>>>
>>>> And it's not infinite nested simulation because Hb simulates Pa past
>>>> the point where Ha aborts, sees that the embedded copy of Ha aborts,
>>>> and sees Pa halt. So Ha is wrong.
>>> This is factually incorrect. The outermost H sees the infinite behavior
>>> pattern first and knows that if it doesn't abort the simulation of its
>>> input after a fixed number of simulations that the input will never
>>> stop. I set this fixed number at the minimum of 2.
>>
>> There is no "if it doesn't abort" because then you're talking about Pn
>> instead of Pa.  Because Pa contains a copy of Ha, you can't talk about
>> what would happen if Ha did something different.  Ha has a *fixed*
>> algorithm,  so it *does* abort, meaning the embedded copy in Pa will
>> also abort.  So there is no infinite simulation pattern to be found
>> and Ha aborts too soon as Hb demonstrates.
>
> I am only talking about the actual behavior of the literal string H and
> H1 applied to the literal string P. If you talk about anything else you
> are talking to yourself and not me.


Click here to read the complete article
Re: On Strachey [ How nuts is that? ]

<2YheK.9$w1W1.1@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx47.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.9.0
Subject: Re: On Strachey [ How nuts is that? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220505204551.00001f5f@reddwarf.jmc>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com>
<44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com>
<7d578c3d-c493-45fa-aeae-9983ae074999n@googlegroups.com>
<geidnXT6XPWyDuT_nZ2dnUU7_81g4p2d@giganews.com>
<a9cec071-dac5-4865-8b6c-450cf96f5509n@googlegroups.com>
<rY-dnRn-lJqlBOT_nZ2dnUU7_81g4p2d@giganews.com>
<a981d1fa-e6c7-4223-a590-90c158a9c51dn@googlegroups.com>
<QtGdnbyP2sg4AOT_nZ2dnUU7_8xh4p2d@giganews.com>
<d41cf657-d5f2-4928-a240-c16f246b2429n@googlegroups.com>
<duSdnX2ELvoBPOT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <duSdnX2ELvoBPOT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 328
Message-ID: <2YheK.9$w1W1.1@fx47.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 9 May 2022 20:02:07 -0400
X-Received-Bytes: 18318
 by: Richard Damon - Tue, 10 May 2022 00:02 UTC

On 5/9/22 7:19 PM, olcott wrote:
> On 5/9/2022 6:11 PM, wij wrote:
>> On Tuesday, 10 May 2022 at 07:03:08 UTC+8, olcott wrote:
>>> On 5/9/2022 5:53 PM, wij wrote:
>>>> On Tuesday, 10 May 2022 at 06:44:15 UTC+8, olcott wrote:
>>>>> On 5/9/2022 5:34 PM, wij wrote:
>>>>>> On Tuesday, 10 May 2022 at 06:18:31 UTC+8, olcott wrote:
>>>>>>> On 5/9/2022 4:51 PM, wij wrote:
>>>>>>>> On Tuesday, 10 May 2022 at 05:20:02 UTC+8, olcott wrote:
>>>>>>>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:
>>>>>>>>>> On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 8:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 7:48 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 6:35 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 5:47 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 8:07 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 7:11 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting theorem follows,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trivially, from lots of simpler theorems,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of which have you bothered to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> read. In Linz, the theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presented as a corollary of a simpler
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theorem in chapter 11.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11.3, 11.4, and 11.5. I will look at them.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the change of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> heart?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is enough progress now that I don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have to have an absolutely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single-minded focus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Progress?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS AN EASILY VERIFIABLE FACT:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P as input parameters and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly compute the mapping from this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to an accept ore reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that these inputs actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not decide the halting of P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return (N + M);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not supposed to in the same way that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(3,4) is not supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide the sum of (5,7).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why is this so difficult for you?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You know that if anyone insisted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(3,4) must return the value of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(5,7) that they are wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then why do you insist that H(P,P) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>> return the value of H(Pn,Pn)?
>>>>>>>>>>>>>>>>>>>>>>>>>>> The definition of decider requires it to
>>>>>>>>>>>>>>>>>>>>>>>>>>> based its decision on whatever
>>>>>>>>>>>>>>>>>>>>>>>>>>> its input specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which in the case of H(P,P) is *defined* to be
>>>>>>>>>>>>>>>>>>>>>>>>>> P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> In this case it is the same as if {dogs} are
>>>>>>>>>>>>>>>>>>>>>>>>> defined to be {cats}.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So no rebuttal, just a bad analogy.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H(P,P) and H1(P,P) use this exact
>>>>>>>>>>>>>>>>>>>>>>>>>>> literal byte string as their
>>>>>>>>>>>>>>>>>>>>>>>>>>> input therefore it seems enormously dishonest
>>>>>>>>>>>>>>>>>>>>>>>>>>> of you to refer to the
>>>>>>>>>>>>>>>>>>>>>>>>>>> same literal string using different
>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicating a difference
>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same string with itself.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> What I was saying is that you think that H
>>>>>>>>>>>>>>>>>>>>>>>>>> sees infinite simulation which only exists in
>>>>>>>>>>>>>>>>>>>>>>>>>> Pn(Pn)
>>>>>>>>>>>>>>>>>>>>>>>>> All that crazy bullshit about subscripted names
>>>>>>>>>>>>>>>>>>>>>>>>> of subscripts is
>>>>>>>>>>>>>>>>>>>>>>>>> extremely deceptive
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, just the opposite. It makes it clear
>>>>>>>>>>>>>>>>>>>>>>>> *exactly* which computation we're talking about,
>>>>>>>>>>>>>>>>>>>>>>>> so it prevents YOU from being deceptive.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> I am ONLY referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> as x86 machine code correctly simulated by
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) and H1(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No you're not. You're also referring to the
>>>>>>>>>>>>>>>>>>>>>>>> literal string which is the fixed code of H
>>>>>>>>>>>>>>>>>>>>>>>> which aborts as that is part of the program P.
>>>>>>>>>>>>>>>>>>>>>>>> So from here on, we'll refer to H as Ha and P as
>>>>>>>>>>>>>>>>>>>>>>>> Pa to make that point clear.
>>>>>>>>>>>>>>>>>>>>>>> I am only referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> as an input to H(P,P) and H1(P,P). It is 100%
>>>>>>>>>>>>>>>>>>>>>>> perfectly concrete
>>>>>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>>>>>> utterly impervious to even extremely well-crafted
>>>>>>>>>>>>>>>>>>>>>>> attempts at deception
>>>>>>>>>>>>>>>>>>>>>>> through the strawman error. Any attempt to get
>>>>>>>>>>>>>>>>>>>>>>> around this will be
>>>>>>>>>>>>>>>>>>>>>>> construed as (and labeled) a bald-faced lie by a
>>>>>>>>>>>>>>>>>>>>>>> bald-faced liar.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That string is 100% NOT concrete because it
>>>>>>>>>>>>>>>>>>>>>> doesn't specify the function that it is calling.
>>>>>>>>>>>>>>>>>>>>> I did not freaking say that this finite string
>>>>>>>>>>>>>>>>>>>>> specifies every freaking
>>>>>>>>>>>>>>>>>>>>> detail of the whole freaking system nitwit. This
>>>>>>>>>>>>>>>>>>>>> finite string as x86
>>>>>>>>>>>>>>>>>>>>> code specifies every one of its own bytes.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Not the whole system, just the computation to be
>>>>>>>>>>>>>>>>>>>> decided on, and that computation includes the FIXED
>>>>>>>>>>>>>>>>>>>> code of H that aborts its simulation, i.e. Ha.
>>>>>>>>>>>>>>>>>>> Thee is no Pa, Pb, Pc, there is only this P:
>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So if that's enough information to decide on, then
>>>>>>>>>>>>>>>>>> tell me if this halts:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> void F()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>> X()
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am only talking about H(P,P) and H1(P,P) where P is
>>>>>>>>>>>>>>>>> this literal
>>>>>>>>>>>>>>>>> string as x86 machine language:
>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again, not a complete computation, so not enough
>>>>>>>>>>>>>>>> information to decide on. You seem to think that all "P"
>>>>>>>>>>>>>>>> constructs are the same no matter how different the H it
>>>>>>>>>>>>>>>> is built on is.
>>>>>>>>>>>>>>> Within the context of my paper it is a complete
>>>>>>>>>>>>>>> computation for H(P,P).
>>>>>>>>>>>>>>> I am updating the paper to include H1(P,P).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So if H is the *specific* decider that can detect infinite
>>>>>>>>>>>>>> simulation in Pn(Pn), then we'll refer to it as Ha to
>>>>>>>>>>>>>> clarify that point, and we'll refer to the P that calls it
>>>>>>>>>>>>>> as Pa to clarify.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I am talking about the literal string of "H" being applied
>>>>>>>>>>>>> to this
>>>>>>>>>>>>> literal string:
>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>
>>>>>>>>>>>>> and
>>>>>>>>>>>>>
>>>>>>>>>>>>> The literal string of "H1" being applied to this literal
>>>>>>>>>>>>> string:
>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>
>>>>>>>>>>>> And to complete the computation being evaluated, what is the
>>>>>>>>>>>> *exact*, FIXED algorithm of H? If it is Ha, then Ha(Pa,Pa)
>>>>>>>>>>>> == false is wrong as demonstrated by Hb(Pa,Pa) == true.
>>>>>>>>>>>>
>>>>>>>>>>>> If H is using some other algorithm, then specify the *exact*
>>>>>>>>>>>> algorithm.
>>>>>>>>>>> H and H1 are both literal byte strings that emulate their
>>>>>>>>>>> literal byte
>>>>>>>>>>> string input in pure x86 emulation mode until the behavior of
>>>>>>>>>>> this
>>>>>>>>>>> emulated literal byte string input shows that it would never
>>>>>>>>>>> reach its
>>>>>>>>>>> own final state (0xc3 ret instruction).
>>>>>>>>>>
>>>>>>>>>> So in other words, the fixed algorithm of H looks for what it
>>>>>>>>>> thinks is infinite simulation. So H is Ha, which means P is Pa.
>>>>>>>>>>
>>>>>>>>>> Hb can then be constructed to simulate for k more steps than
>>>>>>>>>> Ha and calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false
>>>>>>>>>> wrong.
>>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>> machine stack stack machine assembly
>>>>>>>>> address address data code language
>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 //
>>>>>>>>> Call H
>>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 //
>>>>>>>>> Call H
>>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>>>
>>>>>>>>> The fact that P calls the same function from its same machine
>>>>>>>>> address
>>>>>>>>> with identical input parameters conclusively proves that P is
>>>>>>>>> stuck in
>>>>>>>>> infinite recursion.
>>>>>>>>> --
>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>
>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>> Arthur Schopenhauer
>>>>>>>>
>>>>>>>> Your coding is invalid, because H is now shown to exist.
>>>>>>> I provide all of the details proving that this H does exist.
>>>>>>
>>>>>> Sorry, I don't think anyone had ever seen one.
>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>
>>>>
>>>> "H is here" does not mean "I provide all of the details proving that
>>>> this H does exist."
>>>> Where is your H that can stand the HP test?
>>> We can verify that H(P,P) correctly emulates its input on the basis that
>>> the execution trace provided by H exactly matches the behavior specified
>>> by the x86 source-code of P.
>>> _P()
>>> [00001352](01) 55 push ebp
>>> [00001353](02) 8bec mov ebp,esp
>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>> [00001358](01) 50 push eax
>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>> [0000135c](01) 51 push ecx
>>> [0000135d](05) e840feffff call 000011a2 // call H
>>> [00001362](03) 83c408 add esp,+08
>>> [00001365](02) 85c0 test eax,eax
>>> [00001367](02) 7402 jz 0000136b
>>> [00001369](02) ebfe jmp 00001369
>>> [0000136b](01) 5d pop ebp
>>> [0000136c](01) c3 ret
>>> Size in bytes:(0027) [0000136c]
>>>
>>> The execution trace that H(P,P) bases its halt status decision on
>>> Begin Local Halt Decider Simulation Execution Trace Stored at:25cd7a
>>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
>>> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
>>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
>>> ...[00001358][0025cd62][00001352] 50 push eax
>>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
>>> ...[0000135c][0025cd5e][00001352] 51 push ecx
>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>>> ...[00001352][002a778e][002a7792] 55 push ebp // enter P
>>> ...[00001353][002a778e][002a7792] 8bec mov ebp,esp
>>> ...[00001355][002a778e][002a7792] 8b4508 mov eax,[ebp+08]
>>> ...[00001358][002a778a][00001352] 50 push eax // push P
>>> ...[00001359][002a778a][00001352] 8b4d08 mov ecx,[ebp+08]
>>> ...[0000135c][002a7786][00001352] 51 push ecx // push P
>>> ...[0000135d][002a7782][00001362] e840feffff call 000011a2 // call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>> H sees that P is calling the same function from the same machine address
>>> with identical parameters, twice in sequence. This is the infinite
>>> recursion non-halting behavior pattern.
>>> --
>>> Copyright 2022 Pete Olcott
>>>
>>> "Talent hits a target no one else can hit;
>>> Genius hits a target no one else can see."
>>> Arthur Schopenhauer
>>
>> This is not H (a halting decider).
>
> It does correctly decide the one "impossible" input basis of all of the
> proofs, thus refuting all of these proofs.


Click here to read the complete article
Re: On Strachey [ How nuts is that? ]

<t5chnv$c3o$1@dont-email.me>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: jbb...@notatt.com (Jeff Barnett)
Newsgroups: comp.theory
Subject: Re: On Strachey [ How nuts is that? ]
Date: Mon, 9 May 2022 20:13:16 -0600
Organization: A noiseless patient Spider
Lines: 76
Message-ID: <t5chnv$c3o$1@dont-email.me>
References: <20220505204551.00001f5f@reddwarf.jmc>
<8599ac1b-30c1-49b8-ad8a-0811b3d581b3n@googlegroups.com>
<e-CdnRRLy4B5ter_nZ2dnUU7_83NnZ2d@giganews.com>
<d5dd6404-05b7-4fa4-add5-87cc7d22e54cn@googlegroups.com>
<Rv-dndhesPYhruT_nZ2dnUU7_83NnZ2d@giganews.com>
<83cf00e9-83c4-4be0-8874-9c9d042947a3n@googlegroups.com>
<SdudnWkwTth8puT_nZ2dnUU7_83NnZ2d@giganews.com>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com>
<44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com> <t5c3jo$kcb$1@dont-email.me>
<tvCdnal6wOT1CuT_nZ2dnUU7_83NnZ2d@giganews.com>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: base64
Injection-Date: Tue, 10 May 2022 02:13:20 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="0342975f941ea277319df9b16d949731";
logging-data="12408"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX19Op4Ucv7hfCpHnjsFP3+tu5Ss1IdOffQ4="
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Cancel-Lock: sha1:u8jq68beajzqb3n53Qm0fnhcgvY=
In-Reply-To: <tvCdnal6wOT1CuT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Language: en-US
 by: Jeff Barnett - Tue, 10 May 2022 02:13 UTC

On 5/9/2022 4:36 PM, olcott wrote:
> On 5/9/2022 5:12 PM, Jeff Barnett wrote:
>> On 5/9/2022 3:19 PM, olcott wrote:
>>
>> SNIP
>>
>>>> So in other words, the fixed algorithm of H looks for what it thinks
>>>> is infinite simulation.  So H is Ha, which means P is Pa.
>>>>
>>>> Hb can then be constructed to simulate for k more steps than Ha and
>>>> calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>>
>>> Begin Local Halt Decider Simulation
>>>      machine   stack     stack     machine    assembly
>>>      address   address   data      code       language
>>>      ========  ========  ========  =========  =============
>>> ...[000009d6][00211368][0021136c] 55         push ebp         // enter P
>>> ...[000009d7][00211368][0021136c] 8bec       mov ebp,esp
>>> ...[000009d9][00211368][0021136c] 8b4508     mov eax,[ebp+08]
>>> ...[000009dc][00211364][000009d6] 50         push eax         // Push P
>>> ...[000009dd][00211364][000009d6] 8b4d08     mov ecx,[ebp+08]
>>> ...[000009e0][00211360][000009d6] 51         push ecx         // Push P
>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826    // Call H
>>> ...[000009d6][0025bd90][0025bd94] 55         push ebp         // enter P
>>> ...[000009d7][0025bd90][0025bd94] 8bec       mov ebp,esp
>>> ...[000009d9][0025bd90][0025bd94] 8b4508     mov eax,[ebp+08]
>>> ...[000009dc][0025bd8c][000009d6] 50         push eax         // Push P
>>> ...[000009dd][0025bd8c][000009d6] 8b4d08     mov ecx,[ebp+08]
>>> ...[000009e0][0025bd88][000009d6] 51         push ecx         // Push P
>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826    // Call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> The fact that P calls the same function from its same machine address
>>> with identical input parameters conclusively proves that P is stuck
>>> in infinite recursion.
>>
>> Let's say that H looks like
>>
>>     Procedure H(args...)
>>      Declare foo Own integer initially 10,000;
>>      foo <- foo - 1;
>>      If foo = 0 then signal ("halt 10000");
>>      do stuff .....
>>      Return ;
>>      End H;
>>
>> Then your simulation is total crap.
>
> It is already stipulated (and verifiable) that H(P,P) correctly emulates
> its input until it aborts the emulation of this input.
You can stipulate all you want. However, you are unreliable so lets
ignore that. Since you haven't shown your H and I've shown you mine, I
win. For the next lesson, we are told that "....." contains "H(.....)"
and that form is sometimes executed. All it proves is that your test in
your code does not justify the conclusion in re infinite recursion.
You can not and have not convinced anyone. And you wont unless some well
written code (insert guffaw here) that justifies your claims. It's time
to put up or shut up (second choice is best for you). I can change my H
slightly to assure H is not called with the same argument but the
argument will have the same address. Then what? You try to change the
definition of halting again? Or what a halt decider must do?
> We can verify that H(P,P) correctly emulates its input on the basis that
> the execution trace provided by H exactly matches the behavior specified
> by the x86 source-code of P.
>
>
>>  Put up (show H, your coding is known untrustworthy) or shut up (this
>> option would be most appreciated). If you don't know what "Own" is,
>> ask Ben. So far, he's been charitable with his time and might help
>> you. Or you can try Google.
>>
>> [By the way, there was an ambiguity about Own in an Algol spec that
>> might be in play here since you claim that H is in a recursive loop.
>> Fortunately, that will not effect the point of the above, it will just
>> strengthen the effect no matter what the interpretation.]--
Jeff Barnett

Re: On Strachey [ How nuts is that? ]

<1pCdnTVCcKj5R-T_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
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: Mon, 09 May 2022 22:22:12 -0500
Date: Mon, 9 May 2022 22:22:10 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: On Strachey [ How nuts is that? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220505204551.00001f5f@reddwarf.jmc>
<lsWdnfMrnI6Xher_nZ2dnUU7_8zNnZ2d@giganews.com>
<8599ac1b-30c1-49b8-ad8a-0811b3d581b3n@googlegroups.com>
<e-CdnRRLy4B5ter_nZ2dnUU7_83NnZ2d@giganews.com>
<d5dd6404-05b7-4fa4-add5-87cc7d22e54cn@googlegroups.com>
<Rv-dndhesPYhruT_nZ2dnUU7_83NnZ2d@giganews.com>
<83cf00e9-83c4-4be0-8874-9c9d042947a3n@googlegroups.com>
<SdudnWkwTth8puT_nZ2dnUU7_83NnZ2d@giganews.com>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com>
<44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com> <t5c3jo$kcb$1@dont-email.me>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <t5c3jo$kcb$1@dont-email.me>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <1pCdnTVCcKj5R-T_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 76
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sX4jtkvixteIW+YsVeD4aBz6jpgA3Jwcgqcbh27fm4LxR85eQb+UmwKhc3O7Xf17mBQH0vQInMxA1yY!ert541bDXvvT3OiSwfIWI1qKxHdIwCpgHX9C8IcsU8uG2fSVJDgKAqL7TFK84AJ2Y2n+zUG7pR0=
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: 5482
 by: olcott - Tue, 10 May 2022 03:22 UTC

On 5/9/2022 5:12 PM, Jeff Barnett wrote:
> On 5/9/2022 3:19 PM, olcott wrote:
>
> SNIP
>
>>> So in other words, the fixed algorithm of H looks for what it thinks
>>> is infinite simulation.  So H is Ha, which means P is Pa.
>>>
>>> Hb can then be constructed to simulate for k more steps than Ha and
>>> calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>
>> Begin Local Halt Decider Simulation
>>      machine   stack     stack     machine    assembly
>>      address   address   data      code       language
>>      ========  ========  ========  =========  =============
>> ...[000009d6][00211368][0021136c] 55         push ebp         // enter P
>> ...[000009d7][00211368][0021136c] 8bec       mov ebp,esp
>> ...[000009d9][00211368][0021136c] 8b4508     mov eax,[ebp+08]
>> ...[000009dc][00211364][000009d6] 50         push eax         // Push P
>> ...[000009dd][00211364][000009d6] 8b4d08     mov ecx,[ebp+08]
>> ...[000009e0][00211360][000009d6] 51         push ecx         // Push P
>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826    // Call H
>> ...[000009d6][0025bd90][0025bd94] 55         push ebp         // enter P
>> ...[000009d7][0025bd90][0025bd94] 8bec       mov ebp,esp
>> ...[000009d9][0025bd90][0025bd94] 8b4508     mov eax,[ebp+08]
>> ...[000009dc][0025bd8c][000009d6] 50         push eax         // Push P
>> ...[000009dd][0025bd8c][000009d6] 8b4d08     mov ecx,[ebp+08]
>> ...[000009e0][0025bd88][000009d6] 51         push ecx         // Push P
>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826    // Call H
>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>
>> The fact that P calls the same function from its same machine address
>> with identical input parameters conclusively proves that P is stuck in
>> infinite recursion.
>
> Let's say that H looks like
>
>    Procedure H(args...)
>     Declare foo Own integer initially 10,000;
>     foo <- foo - 1;
>     If foo = 0 then signal ("halt 10000");
>     do stuff .....
>     Return ;
>     End H;
>
> Then your simulation is total crap.

> Put up (show H, your coding is known
> untrustworthy) or shut up (this option would be most appreciated).

We can verify that H(P,P) correctly emulates its input on the basis that
the execution trace provided by H exactly matches the behavior specified
by the x86 source-code of P.

That you are unwilling do do this proves your insincerity.
It is already succinctly proved in the material that was provided.

> If
> you don't know what "Own" is, ask Ben. So far, he's been charitable with
> his time and might help you. Or you can try Google.
>
> [By the way, there was an ambiguity about Own in an Algol spec that
> might be in play here since you claim that H is in a recursive loop.
> Fortunately, that will not effect the point of the above, it will just
> strengthen the effect no matter what the interpretation.]
> --
> Jeff Barnett

--
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: On Strachey [ How nuts is that? ]

<_7leK.10227$RWva.9485@fx96.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx96.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.9.0
Subject: Re: On Strachey [ How nuts is that? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220505204551.00001f5f@reddwarf.jmc>
<8599ac1b-30c1-49b8-ad8a-0811b3d581b3n@googlegroups.com>
<e-CdnRRLy4B5ter_nZ2dnUU7_83NnZ2d@giganews.com>
<d5dd6404-05b7-4fa4-add5-87cc7d22e54cn@googlegroups.com>
<Rv-dndhesPYhruT_nZ2dnUU7_83NnZ2d@giganews.com>
<83cf00e9-83c4-4be0-8874-9c9d042947a3n@googlegroups.com>
<SdudnWkwTth8puT_nZ2dnUU7_83NnZ2d@giganews.com>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com>
<44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com> <t5c3jo$kcb$1@dont-email.me>
<tvCdnal6wOT1CuT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <tvCdnal6wOT1CuT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 92
Message-ID: <_7leK.10227$RWva.9485@fx96.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Mon, 9 May 2022 23:39:39 -0400
X-Received-Bytes: 5867
 by: Richard Damon - Tue, 10 May 2022 03:39 UTC

On 5/9/22 6:36 PM, olcott wrote:
> On 5/9/2022 5:12 PM, Jeff Barnett wrote:
>> On 5/9/2022 3:19 PM, olcott wrote:
>>
>> SNIP
>>
>>>> So in other words, the fixed algorithm of H looks for what it thinks
>>>> is infinite simulation.  So H is Ha, which means P is Pa.
>>>>
>>>> Hb can then be constructed to simulate for k more steps than Ha and
>>>> calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>>
>>> Begin Local Halt Decider Simulation
>>>      machine   stack     stack     machine    assembly
>>>      address   address   data      code       language
>>>      ========  ========  ========  =========  =============
>>> ...[000009d6][00211368][0021136c] 55         push ebp         // enter P
>>> ...[000009d7][00211368][0021136c] 8bec       mov ebp,esp
>>> ...[000009d9][00211368][0021136c] 8b4508     mov eax,[ebp+08]
>>> ...[000009dc][00211364][000009d6] 50         push eax         // Push P
>>> ...[000009dd][00211364][000009d6] 8b4d08     mov ecx,[ebp+08]
>>> ...[000009e0][00211360][000009d6] 51         push ecx         // Push P
>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826    // Call H
>>> ...[000009d6][0025bd90][0025bd94] 55         push ebp         // enter P
>>> ...[000009d7][0025bd90][0025bd94] 8bec       mov ebp,esp
>>> ...[000009d9][0025bd90][0025bd94] 8b4508     mov eax,[ebp+08]
>>> ...[000009dc][0025bd8c][000009d6] 50         push eax         // Push P
>>> ...[000009dd][0025bd8c][000009d6] 8b4d08     mov ecx,[ebp+08]
>>> ...[000009e0][0025bd88][000009d6] 51         push ecx         // Push P
>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826    // Call H
>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>
>>> The fact that P calls the same function from its same machine address
>>> with identical input parameters conclusively proves that P is stuck
>>> in infinite recursion.
>>
>> Let's say that H looks like
>>
>>     Procedure H(args...)
>>      Declare foo Own integer initially 10,000;
>>      foo <- foo - 1;
>>      If foo = 0 then signal ("halt 10000");
>>      do stuff .....
>>      Return ;
>>      End H;
>>
>> Then your simulation is total crap.
>
> It is already stipulated (and verifiable) that H(P,P) correctly emulates
> its input until it aborts the emulation of this input.

You can't stipu;ate that your answer is correct.

The actual affect of that sipulation is that your H never halts (if you
use the actual Halting Property as your criteria) since if H aborts its
simulation and says non-halting the input becomes Halting.

>
> We can verify that H(P,P) correctly emulates its input on the basis that
> the execution trace provided by H exactly matches the behavior specified
> by the x86 source-code of P.

Nope. Since the ACTUAL behavior of calling H is the execution of H and
of H SIMULATING P, not P actually running.

The ONLY way you can get the trace you show is if H jumps to/calls P, at
which point it can never 'abort' that 'simulation' since it is no longer
in control.

If the embedded copy does that, but the master copy does an actual
simulation, then you didn't put a correct copy of H into P, or H isn't
actually a computation, taking some hidden input.

FAIL

>
>
>>  Put up (show H, your coding is known untrustworthy) or shut up (this
>> option would be most appreciated). If you don't know what "Own" is,
>> ask Ben. So far, he's been charitable with his time and might help
>> you. Or you can try Google.
>>
>> [By the way, there was an ambiguity about Own in an Algol spec that
>> might be in play here since you claim that H is in a recursive loop.
>> Fortunately, that will not effect the point of the above, it will just
>> strengthen the effect no matter what the interpretation.]
>> --
>> Jeff Barnett
>
>

Re: On Strachey [ How nuts is that? ]

<e781315c-4978-4668-aaec-d16c176f89d5n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:7dc1:0:b0:2f3:c70a:df9e with SMTP id c1-20020ac87dc1000000b002f3c70adf9emr17485304qte.307.1652154516928;
Mon, 09 May 2022 20:48:36 -0700 (PDT)
X-Received: by 2002:a25:d55:0:b0:648:7008:61e0 with SMTP id
82-20020a250d55000000b00648700861e0mr15704480ybn.282.1652154516715; Mon, 09
May 2022 20:48:36 -0700 (PDT)
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!proxad.net!feeder1-2.proxad.net!209.85.160.216.MISMATCH!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Mon, 9 May 2022 20:48:36 -0700 (PDT)
In-Reply-To: <1pCdnTVCcKj5R-T_nZ2dnUU7_83NnZ2d@giganews.com>
Injection-Info: google-groups.googlegroups.com; posting-host=71.168.165.242; posting-account=ejFcQgoAAACAt5i0VbkATkR2ACWdgADD
NNTP-Posting-Host: 71.168.165.242
References: <20220505204551.00001f5f@reddwarf.jmc> <lsWdnfMrnI6Xher_nZ2dnUU7_8zNnZ2d@giganews.com>
<8599ac1b-30c1-49b8-ad8a-0811b3d581b3n@googlegroups.com> <e-CdnRRLy4B5ter_nZ2dnUU7_83NnZ2d@giganews.com>
<d5dd6404-05b7-4fa4-add5-87cc7d22e54cn@googlegroups.com> <Rv-dndhesPYhruT_nZ2dnUU7_83NnZ2d@giganews.com>
<83cf00e9-83c4-4be0-8874-9c9d042947a3n@googlegroups.com> <SdudnWkwTth8puT_nZ2dnUU7_83NnZ2d@giganews.com>
<7e25c6b8-ed5c-4740-8851-06c10bd1c491n@googlegroups.com> <44Kdnctn08ZF3uT_nZ2dnUU7_83NnZ2d@giganews.com>
<8d16c2bb-1cf5-4ed0-b7b5-8b472341767cn@googlegroups.com> <AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com> <gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com> <kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com> <LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com>
<t5c3jo$kcb$1@dont-email.me> <1pCdnTVCcKj5R-T_nZ2dnUU7_83NnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <e781315c-4978-4668-aaec-d16c176f89d5n@googlegroups.com>
Subject: Re: On Strachey [ How nuts is that? ]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Tue, 10 May 2022 03:48:36 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Dennis Bush - Tue, 10 May 2022 03:48 UTC

On Monday, May 9, 2022 at 11:22:19 PM UTC-4, olcott wrote:
> On 5/9/2022 5:12 PM, Jeff Barnett wrote:
> > On 5/9/2022 3:19 PM, olcott wrote:
> >
> > SNIP
> >
> >>> So in other words, the fixed algorithm of H looks for what it thinks
> >>> is infinite simulation. So H is Ha, which means P is Pa.
> >>>
> >>> Hb can then be constructed to simulate for k more steps than Ha and
> >>> calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
> >>
> >> Begin Local Halt Decider Simulation
> >> machine stack stack machine assembly
> >> address address data code language
> >> ======== ======== ======== ========= =============
> >> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
> >> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
> >> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
> >> ...[000009dc][00211364][000009d6] 50 push eax // Push P
> >> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
> >> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
> >> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
> >> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
> >> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
> >> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
> >> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
> >> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
> >> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
> >> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
> >> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
> >>
> >> The fact that P calls the same function from its same machine address
> >> with identical input parameters conclusively proves that P is stuck in
> >> infinite recursion.
> >
> > Let's say that H looks like
> >
> > Procedure H(args...)
> > Declare foo Own integer initially 10,000;
> > foo <- foo - 1;
> > If foo = 0 then signal ("halt 10000");
> > do stuff .....
> > Return ;
> > End H;
> >
> > Then your simulation is total crap.
>
>
> > Put up (show H, your coding is known
> > untrustworthy) or shut up (this option would be most appreciated).
> We can verify that H(P,P) correctly emulates its input on the basis that
> the execution trace provided by H exactly matches the behavior specified
> by the x86 source-code of P.

Let's test that. Code up Ha3(N,5). You'll find that the execution trace provided by Ha3 exactly matches the behavior specified by the x86 source code of N.

So then according to you, by your criteria of a correct simulation, Ha3(N,5) == false is correct.

If you believe that's nonsense, then that means your criteria for correct emulation is invalid and therefore can't be used to show that Ha(Pa,Pa) == false is correct.

> That you are unwilling do do this proves your insincerity.
> It is already succinctly proved in the material that was provided.
> > If
> > you don't know what "Own" is, ask Ben. So far, he's been charitable with
> > his time and might help you. Or you can try Google.
> >
> > [By the way, there was an ambiguity about Own in an Algol spec that
> > might be in play here since you claim that H is in a recursive loop.
> > Fortunately, that will not effect the point of the above, it will just
> > strengthen the effect no matter what the interpretation.]
> > --
> > Jeff Barnett
> --
> 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: On Strachey [ How nuts is that? ][ proof that I am correct ]

<49Wdnes54bkUyuf_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic
Followup: comp.theory
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: Tue, 10 May 2022 07:16:09 -0500
Date: Tue, 10 May 2022 07:16:08 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.0
Subject: Re: On Strachey [ How nuts is that? ][ proof that I am correct ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic
References: <20220505204551.00001f5f@reddwarf.jmc>
<AsmdneeUVMtA0eT_nZ2dnUU7_8xh4p2d@giganews.com>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com>
<7d578c3d-c493-45fa-aeae-9983ae074999n@googlegroups.com>
<geidnXT6XPWyDuT_nZ2dnUU7_81g4p2d@giganews.com>
<a9cec071-dac5-4865-8b6c-450cf96f5509n@googlegroups.com>
<rY-dnRn-lJqlBOT_nZ2dnUU7_81g4p2d@giganews.com>
<a981d1fa-e6c7-4223-a590-90c158a9c51dn@googlegroups.com>
<QtGdnbyP2sg4AOT_nZ2dnUU7_8xh4p2d@giganews.com>
<d41cf657-d5f2-4928-a240-c16f246b2429n@googlegroups.com>
<duSdnX2ELvoBPOT_nZ2dnUU7_81g4p2d@giganews.com>
<a6014032-4c59-422e-8a3c-bdb88e068d6fn@googlegroups.com>
<HuCdndTLiYuuOeT_nZ2dnUU7_8zNnZ2d@giganews.com>
<6da7dd3f-87b2-4b06-a7f7-2dd81d219cedn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
Followup-To: comp.theory
In-Reply-To: <6da7dd3f-87b2-4b06-a7f7-2dd81d219cedn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <49Wdnes54bkUyuf_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 378
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-DB7GeBIWIFda6cnx2T7nh7EQe+EUqLTnW8B6jzP1NYlEv3HvBLmc1alM3PtgpIogVfpkfjN3O8y5n7p!2Tj5YWBmAReND3wTYuiCmn65Q+7PlDinvNc0Jnu6SUMnLtq6CWbEyPZYsk3B7yHQTcPObh+4LyM=
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: 23100
 by: olcott - Tue, 10 May 2022 12:16 UTC

On 5/9/2022 6:42 PM, wij wrote:
> On Tuesday, 10 May 2022 at 07:31:07 UTC+8, olcott wrote:
>> On 5/9/2022 6:23 PM, wij wrote:
>>> On Tuesday, 10 May 2022 at 07:20:03 UTC+8, olcott wrote:
>>>> On 5/9/2022 6:11 PM, wij wrote:
>>>>> On Tuesday, 10 May 2022 at 07:03:08 UTC+8, olcott wrote:
>>>>>> On 5/9/2022 5:53 PM, wij wrote:
>>>>>>> On Tuesday, 10 May 2022 at 06:44:15 UTC+8, olcott wrote:
>>>>>>>> On 5/9/2022 5:34 PM, wij wrote:
>>>>>>>>> On Tuesday, 10 May 2022 at 06:18:31 UTC+8, olcott wrote:
>>>>>>>>>> On 5/9/2022 4:51 PM, wij wrote:
>>>>>>>>>>> On Tuesday, 10 May 2022 at 05:20:02 UTC+8, olcott wrote:
>>>>>>>>>>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 8:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 7:48 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 6:35 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 5:47 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 8:07 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 7:11 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting theorem follows, trivially, from lots of simpler theorems,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of which have you bothered to read. In Linz, the theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presented as a corollary of a simpler theorem in chapter 11.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11.3, 11.4, and 11.5. I will look at them.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the change of heart?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is enough progress now that I don't have to have an absolutely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single-minded focus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Progress?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS AN EASILY VERIFIABLE FACT:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine code of P as input parameters and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly compute the mapping from this input to an accept ore reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual behavior that these inputs actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not decide the halting of P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return (N + M);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not supposed to in the same way that sum(3,4) is not supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide the sum of (5,7).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why is this so difficult for you?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You know that if anyone insisted that sum(3,4) must return the value of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(5,7) that they are wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then why do you insist that H(P,P) must return the value of H(Pn,Pn)?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The definition of decider requires it to based its decision on whatever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which in the case of H(P,P) is *defined* to be P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> In this case it is the same as if {dogs} are defined to be {cats}.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So no rebuttal, just a bad analogy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H(P,P) and H1(P,P) use this exact literal byte string as their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input therefore it seems enormously dishonest of you to refer to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same literal string using different subscripts indicating a difference
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same string with itself.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What I was saying is that you think that H sees infinite simulation which only exists in Pn(Pn)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> All that crazy bullshit about subscripted names of subscripts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> extremely deceptive
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, just the opposite. It makes it clear *exactly* which computation we're talking about, so it prevents YOU from being deceptive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am ONLY referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>>>> as x86 machine code correctly simulated by H(P,P) and H1(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No you're not. You're also referring to the literal string which is the fixed code of H which aborts as that is part of the program P. So from here on, we'll refer to H as Ha and P as Pa to make that point clear.
>>>>>>>>>>>>>>>>>>>>>>>>>> I am only referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> as an input to H(P,P) and H1(P,P). It is 100% perfectly concrete
>>>>>>>>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>>>>>>>>> utterly impervious to even extremely well-crafted attempts at deception
>>>>>>>>>>>>>>>>>>>>>>>>>> through the strawman error. Any attempt to get around this will be
>>>>>>>>>>>>>>>>>>>>>>>>>> construed as (and labeled) a bald-faced lie by a bald-faced liar.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That string is 100% NOT concrete because it doesn't specify the function that it is calling.
>>>>>>>>>>>>>>>>>>>>>>>> I did not freaking say that this finite string specifies every freaking
>>>>>>>>>>>>>>>>>>>>>>>> detail of the whole freaking system nitwit. This finite string as x86
>>>>>>>>>>>>>>>>>>>>>>>> code specifies every one of its own bytes.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Not the whole system, just the computation to be decided on, and that computation includes the FIXED code of H that aborts its simulation, i.e. Ha.
>>>>>>>>>>>>>>>>>>>>>> Thee is no Pa, Pb, Pc, there is only this P:
>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So if that's enough information to decide on, then tell me if this halts:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void F()
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>> X()
>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I am only talking about H(P,P) and H1(P,P) where P is this literal
>>>>>>>>>>>>>>>>>>>> string as x86 machine language:
>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Again, not a complete computation, so not enough information to decide on. You seem to think that all "P" constructs are the same no matter how different the H it is built on is.
>>>>>>>>>>>>>>>>>> Within the context of my paper it is a complete computation for H(P,P).
>>>>>>>>>>>>>>>>>> I am updating the paper to include H1(P,P).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So if H is the *specific* decider that can detect infinite simulation in Pn(Pn), then we'll refer to it as Ha to clarify that point, and we'll refer to the P that calls it as Pa to clarify.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I am talking about the literal string of "H" being applied to this
>>>>>>>>>>>>>>>> literal string: 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The literal string of "H1" being applied to this literal string:
>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And to complete the computation being evaluated, what is the *exact*, FIXED algorithm of H? If it is Ha, then Ha(Pa,Pa) == false is wrong as demonstrated by Hb(Pa,Pa) == true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If H is using some other algorithm, then specify the *exact* algorithm.
>>>>>>>>>>>>>> H and H1 are both literal byte strings that emulate their literal byte
>>>>>>>>>>>>>> string input in pure x86 emulation mode until the behavior of this
>>>>>>>>>>>>>> emulated literal byte string input shows that it would never reach its
>>>>>>>>>>>>>> own final state (0xc3 ret instruction).
>>>>>>>>>>>>>
>>>>>>>>>>>>> So in other words, the fixed algorithm of H looks for what it thinks is infinite simulation. So H is Ha, which means P is Pa.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Hb can then be constructed to simulate for k more steps than Ha and calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa) == false wrong.
>>>>>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>> address address data code language
>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826 // Call H
>>>>>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826 // Call H
>>>>>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that P calls the same function from its same machine address
>>>>>>>>>>>> with identical input parameters conclusively proves that P is stuck in
>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>> --
>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>
>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>
>>>>>>>>>>> Your coding is invalid, because H is now shown to exist.
>>>>>>>>>> I provide all of the details proving that this H does exist.
>>>>>>>>>
>>>>>>>>> Sorry, I don't think anyone had ever seen one.
>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>
>>>>>>> "H is here" does not mean "I provide all of the details proving that this H does exist."
>>>>>>> Where is your H that can stand the HP test?
>>>>>> We can verify that H(P,P) correctly emulates its input on the basis that
>>>>>> the execution trace provided by H exactly matches the behavior specified
>>>>>> by the x86 source-code of P.
>>>>>> _P()
>>>>>> [00001352](01) 55 push ebp
>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>> [00001358](01) 50 push eax
>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>> [0000135c](01) 51 push ecx
>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>> [0000136b](01) 5d pop ebp
>>>>>> [0000136c](01) c3 ret
>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>
>>>>>> The execution trace that H(P,P) bases its halt status decision on
>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored at:25cd7a
>>>>>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
>>>>>> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
>>>>>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
>>>>>> ...[00001358][0025cd62][00001352] 50 push eax
>>>>>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
>>>>>> ...[0000135c][0025cd5e][00001352] 51 push ecx
>>>>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>>>>>> ...[00001352][002a778e][002a7792] 55 push ebp // enter P
>>>>>> ...[00001353][002a778e][002a7792] 8bec mov ebp,esp
>>>>>> ...[00001355][002a778e][002a7792] 8b4508 mov eax,[ebp+08]
>>>>>> ...[00001358][002a778a][00001352] 50 push eax // push P
>>>>>> ...[00001359][002a778a][00001352] 8b4d08 mov ecx,[ebp+08]
>>>>>> ...[0000135c][002a7786][00001352] 51 push ecx // push P
>>>>>> ...[0000135d][002a7782][00001362] e840feffff call 000011a2 // call H
>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>> H sees that P is calling the same function from the same machine address
>>>>>> with identical parameters, twice in sequence. This is the infinite
>>>>>> recursion non-halting behavior pattern.
>>>>>> --
>>>>>> Copyright 2022 Pete Olcott
>>>>>>
>>>>>> "Talent hits a target no one else can hit;
>>>>>> Genius hits a target no one else can see."
>>>>>> Arthur Schopenhauer
>>>>>
>>>>> This is not H (a halting decider).
>>>> It does correctly decide the one "impossible" input basis of all of the
>>>> proofs, thus refuting all of these proofs.
>>>
>>> "it" does not exist. Show your POOH.
>>>
>>> To refute HP, a H has to exist to refute. If H does not exist, no real rebuttal exist.
>> There is no need to show the hundreds of pages of source code for H
>> (including the open source x86 emulator) or the hundreds of pages of
>> execution trace of H because it is easily verified that:
>
> You choose to refute the conventional HP, and says that there is no need to show
> the hundreds of pages of H...,etc. How do you expect the reviewer/the world
> to verify POOH (a claim?) by 'claim'?
>


Click here to read the complete article
Re: On Strachey [ How nuts is that? ][ proof that I am correct ]

<DtCeK.2$NMxb.0@fx02.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx02.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.9.0
Subject: Re: On Strachey [ How nuts is that? ][ proof that I am correct ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220505204551.00001f5f@reddwarf.jmc>
<87d5bb10-0929-467a-8e33-66f452cd76a3n@googlegroups.com>
<gcGdneOEGpRe6-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<d0755e2a-dff7-430d-ba03-83365f303e81n@googlegroups.com>
<kpGdnf_ewfJ44-T_nZ2dnUU7_8zNnZ2d@giganews.com>
<20210cd4-f930-4d0a-a06a-6b4d33458f3cn@googlegroups.com>
<LK6dnT-J09rmGOT_nZ2dnUU7_8zNnZ2d@giganews.com>
<7d578c3d-c493-45fa-aeae-9983ae074999n@googlegroups.com>
<geidnXT6XPWyDuT_nZ2dnUU7_81g4p2d@giganews.com>
<a9cec071-dac5-4865-8b6c-450cf96f5509n@googlegroups.com>
<rY-dnRn-lJqlBOT_nZ2dnUU7_81g4p2d@giganews.com>
<a981d1fa-e6c7-4223-a590-90c158a9c51dn@googlegroups.com>
<QtGdnbyP2sg4AOT_nZ2dnUU7_8xh4p2d@giganews.com>
<d41cf657-d5f2-4928-a240-c16f246b2429n@googlegroups.com>
<duSdnX2ELvoBPOT_nZ2dnUU7_81g4p2d@giganews.com>
<a6014032-4c59-422e-8a3c-bdb88e068d6fn@googlegroups.com>
<HuCdndTLiYuuOeT_nZ2dnUU7_8zNnZ2d@giganews.com>
<6da7dd3f-87b2-4b06-a7f7-2dd81d219cedn@googlegroups.com>
<49Wdnes54bkUyuf_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <49Wdnes54bkUyuf_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 493
Message-ID: <DtCeK.2$NMxb.0@fx02.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: Tue, 10 May 2022 19:23:17 -0400
X-Received-Bytes: 26870
 by: Richard Damon - Tue, 10 May 2022 23:23 UTC

On 5/10/22 8:16 AM, olcott wrote:
> On 5/9/2022 6:42 PM, wij wrote:
>> On Tuesday, 10 May 2022 at 07:31:07 UTC+8, olcott wrote:
>>> On 5/9/2022 6:23 PM, wij wrote:
>>>> On Tuesday, 10 May 2022 at 07:20:03 UTC+8, olcott wrote:
>>>>> On 5/9/2022 6:11 PM, wij wrote:
>>>>>> On Tuesday, 10 May 2022 at 07:03:08 UTC+8, olcott wrote:
>>>>>>> On 5/9/2022 5:53 PM, wij wrote:
>>>>>>>> On Tuesday, 10 May 2022 at 06:44:15 UTC+8, olcott wrote:
>>>>>>>>> On 5/9/2022 5:34 PM, wij wrote:
>>>>>>>>>> On Tuesday, 10 May 2022 at 06:18:31 UTC+8, olcott wrote:
>>>>>>>>>>> On 5/9/2022 4:51 PM, wij wrote:
>>>>>>>>>>>> On Tuesday, 10 May 2022 at 05:20:02 UTC+8, olcott wrote:
>>>>>>>>>>>>> On 5/9/2022 3:59 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Monday, May 9, 2022 at 4:51:57 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/9/2022 3:27 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 4:18:04 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/9/2022 12:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 1:18:28 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:52 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:39:59 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:30 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 12:06:01 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/9/2022 11:02 AM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Monday, May 9, 2022 at 11:31:16 AM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 9:36 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 10:20:27 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 8:26 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 9:08:33 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 7:48 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 8:19:40 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 6:35 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Saturday, May 7, 2022 at 7:14:57 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/7/2022 5:47 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 8:07 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <polc...@gmail.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/6/2022 7:11 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting theorem follows,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trivially, from lots of simpler
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> theorems,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> none of which have you bothered to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> read. In Linz, the theorem is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> presented as a corollary of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simpler theorem in chapter 11.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11.3, 11.4, and 11.5. I will look
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> at them.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Goodness! A good move. Why the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> change of heart?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> There is enough progress now that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't have to have an absolutely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> single-minded focus.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Progress?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THIS IS AN EASILY VERIFIABLE FACT:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H() and H1() take the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code of P as input parameters and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly compute the mapping from
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this input to an accept ore reject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state on the basis of the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that these inputs actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specify.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not decide the halting of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int sum(int N , int M)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return (N + M);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is not supposed to in the same way
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that sum(3,4) is not supposed to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provide the sum of (5,7).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Why is this so difficult for you?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You know that if anyone insisted that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(3,4) must return the value of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sum(5,7) that they are wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then why do you insist that H(P,P) must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> return the value of H(Pn,Pn)?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The definition of decider requires it to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> based its decision on whatever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which in the case of H(P,P) is *defined*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to be P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> In this case it is the same as if {dogs}
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> are defined to be {cats}.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So no rebuttal, just a bad analogy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Both H(P,P) and H1(P,P) use this exact
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> literal byte string as their
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input therefore it seems enormously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> dishonest of you to refer to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> same literal string using different
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subscripts indicating a difference
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the same string with itself.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> What I was saying is that you think that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sees infinite simulation which only exists
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in Pn(Pn)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All that crazy bullshit about subscripted
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> names of subscripts is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extremely deceptive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, just the opposite. It makes it clear
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *exactly* which computation we're talking
>>>>>>>>>>>>>>>>>>>>>>>>>>>> about, so it prevents YOU from being deceptive.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am ONLY referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> as x86 machine code correctly simulated by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) and H1(P,P).
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No you're not. You're also referring to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> literal string which is the fixed code of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> which aborts as that is part of the program
>>>>>>>>>>>>>>>>>>>>>>>>>>>> P. So from here on, we'll refer to H as Ha
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and P as Pa to make that point clear.
>>>>>>>>>>>>>>>>>>>>>>>>>>> I am only referring to this literal string:
>>>>>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> as an input to H(P,P) and H1(P,P). It is 100%
>>>>>>>>>>>>>>>>>>>>>>>>>>> perfectly concrete
>>>>>>>>>>>>>>>>>>>>>>>>>>> thus
>>>>>>>>>>>>>>>>>>>>>>>>>>> utterly impervious to even extremely
>>>>>>>>>>>>>>>>>>>>>>>>>>> well-crafted attempts at deception
>>>>>>>>>>>>>>>>>>>>>>>>>>> through the strawman error. Any attempt to
>>>>>>>>>>>>>>>>>>>>>>>>>>> get around this will be
>>>>>>>>>>>>>>>>>>>>>>>>>>> construed as (and labeled) a bald-faced lie
>>>>>>>>>>>>>>>>>>>>>>>>>>> by a bald-faced liar.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> That string is 100% NOT concrete because it
>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't specify the function that it is calling.
>>>>>>>>>>>>>>>>>>>>>>>>> I did not freaking say that this finite string
>>>>>>>>>>>>>>>>>>>>>>>>> specifies every freaking
>>>>>>>>>>>>>>>>>>>>>>>>> detail of the whole freaking system nitwit.
>>>>>>>>>>>>>>>>>>>>>>>>> This finite string as x86
>>>>>>>>>>>>>>>>>>>>>>>>> code specifies every one of its own bytes.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Not the whole system, just the computation to be
>>>>>>>>>>>>>>>>>>>>>>>> decided on, and that computation includes the
>>>>>>>>>>>>>>>>>>>>>>>> FIXED code of H that aborts its simulation, i.e.
>>>>>>>>>>>>>>>>>>>>>>>> Ha.
>>>>>>>>>>>>>>>>>>>>>>> Thee is no Pa, Pb, Pc, there is only this P:
>>>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So if that's enough information to decide on, then
>>>>>>>>>>>>>>>>>>>>>> tell me if this halts:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void F()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> X()
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I am only talking about H(P,P) and H1(P,P) where P
>>>>>>>>>>>>>>>>>>>>> is this literal
>>>>>>>>>>>>>>>>>>>>> string as x86 machine language:
>>>>>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Again, not a complete computation, so not enough
>>>>>>>>>>>>>>>>>>>> information to decide on. You seem to think that all
>>>>>>>>>>>>>>>>>>>> "P" constructs are the same no matter how different
>>>>>>>>>>>>>>>>>>>> the H it is built on is.
>>>>>>>>>>>>>>>>>>> Within the context of my paper it is a complete
>>>>>>>>>>>>>>>>>>> computation for H(P,P).
>>>>>>>>>>>>>>>>>>> I am updating the paper to include H1(P,P).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So if H is the *specific* decider that can detect
>>>>>>>>>>>>>>>>>> infinite simulation in Pn(Pn), then we'll refer to it
>>>>>>>>>>>>>>>>>> as Ha to clarify that point, and we'll refer to the P
>>>>>>>>>>>>>>>>>> that calls it as Pa to clarify.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I am talking about the literal string of "H" being
>>>>>>>>>>>>>>>>> applied to this
>>>>>>>>>>>>>>>>> literal string:
>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> and
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The literal string of "H1" being applied to this
>>>>>>>>>>>>>>>>> literal string:
>>>>>>>>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And to complete the computation being evaluated, what is
>>>>>>>>>>>>>>>> the *exact*, FIXED algorithm of H? If it is Ha, then
>>>>>>>>>>>>>>>> Ha(Pa,Pa) == false is wrong as demonstrated by Hb(Pa,Pa)
>>>>>>>>>>>>>>>> == true.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If H is using some other algorithm, then specify the
>>>>>>>>>>>>>>>> *exact* algorithm.
>>>>>>>>>>>>>>> H and H1 are both literal byte strings that emulate their
>>>>>>>>>>>>>>> literal byte
>>>>>>>>>>>>>>> string input in pure x86 emulation mode until the
>>>>>>>>>>>>>>> behavior of this
>>>>>>>>>>>>>>> emulated literal byte string input shows that it would
>>>>>>>>>>>>>>> never reach its
>>>>>>>>>>>>>>> own final state (0xc3 ret instruction).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So in other words, the fixed algorithm of H looks for what
>>>>>>>>>>>>>> it thinks is infinite simulation. So H is Ha, which means
>>>>>>>>>>>>>> P is Pa.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Hb can then be constructed to simulate for k more steps
>>>>>>>>>>>>>> than Ha and calculate Hb(Pa,Pa) == true, proving Ha(Pa,Pa)
>>>>>>>>>>>>>> == false wrong.
>>>>>>>>>>>>> Begin Local Halt Decider Simulation
>>>>>>>>>>>>> machine stack stack machine assembly
>>>>>>>>>>>>> address address data code language
>>>>>>>>>>>>> ======== ======== ======== ========= =============
>>>>>>>>>>>>> ...[000009d6][00211368][0021136c] 55 push ebp // enter P
>>>>>>>>>>>>> ...[000009d7][00211368][0021136c] 8bec mov ebp,esp
>>>>>>>>>>>>> ...[000009d9][00211368][0021136c] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> ...[000009dc][00211364][000009d6] 50 push eax // Push P
>>>>>>>>>>>>> ...[000009dd][00211364][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> ...[000009e0][00211360][000009d6] 51 push ecx // Push P
>>>>>>>>>>>>> ...[000009e1][0021135c][000009e6] e840feffff call 00000826
>>>>>>>>>>>>> // Call H
>>>>>>>>>>>>> ...[000009d6][0025bd90][0025bd94] 55 push ebp // enter P
>>>>>>>>>>>>> ...[000009d7][0025bd90][0025bd94] 8bec mov ebp,esp
>>>>>>>>>>>>> ...[000009d9][0025bd90][0025bd94] 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>> ...[000009dc][0025bd8c][000009d6] 50 push eax // Push P
>>>>>>>>>>>>> ...[000009dd][0025bd8c][000009d6] 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>> ...[000009e0][0025bd88][000009d6] 51 push ecx // Push P
>>>>>>>>>>>>> ...[000009e1][0025bd84][000009e6] e840feffff call 00000826
>>>>>>>>>>>>> // Call H
>>>>>>>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation
>>>>>>>>>>>>> Stopped
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that P calls the same function from its same
>>>>>>>>>>>>> machine address
>>>>>>>>>>>>> with identical input parameters conclusively proves that P
>>>>>>>>>>>>> is stuck in
>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>> --
>>>>>>>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>>>>>>>
>>>>>>>>>>>>> "Talent hits a target no one else can hit;
>>>>>>>>>>>>> Genius hits a target no one else can see."
>>>>>>>>>>>>> Arthur Schopenhauer
>>>>>>>>>>>>
>>>>>>>>>>>> Your coding is invalid, because H is now shown to exist.
>>>>>>>>>>> I provide all of the details proving that this H does exist.
>>>>>>>>>>
>>>>>>>>>> Sorry, I don't think anyone had ever seen one.
>>>>>>>>> https://www.researchgate.net/publication/359984584_Halting_problem_undecidability_and_infinitely_nested_simulation_V5
>>>>>>>>>
>>>>>>>>
>>>>>>>> "H is here" does not mean "I provide all of the details proving
>>>>>>>> that this H does exist."
>>>>>>>> Where is your H that can stand the HP test?
>>>>>>> We can verify that H(P,P) correctly emulates its input on the
>>>>>>> basis that
>>>>>>> the execution trace provided by H exactly matches the behavior
>>>>>>> specified
>>>>>>> by the x86 source-code of P.
>>>>>>> _P()
>>>>>>> [00001352](01) 55 push ebp
>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>> [00001358](01) 50 push eax
>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>> [0000135c](01) 51 push ecx
>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>> [0000136c](01) c3 ret
>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>
>>>>>>> The execution trace that H(P,P) bases its halt status decision on
>>>>>>> Begin Local Halt Decider Simulation Execution Trace Stored at:25cd7a
>>>>>>> ...[00001352][0025cd66][0025cd6a] 55 push ebp // enter P
>>>>>>> ...[00001353][0025cd66][0025cd6a] 8bec mov ebp,esp
>>>>>>> ...[00001355][0025cd66][0025cd6a] 8b4508 mov eax,[ebp+08]
>>>>>>> ...[00001358][0025cd62][00001352] 50 push eax
>>>>>>> ...[00001359][0025cd62][00001352] 8b4d08 mov ecx,[ebp+08]
>>>>>>> ...[0000135c][0025cd5e][00001352] 51 push ecx
>>>>>>> ...[0000135d][0025cd5a][00001362] e840feffff call 000011a2 // call H
>>>>>>> ...[00001352][002a778e][002a7792] 55 push ebp // enter P
>>>>>>> ...[00001353][002a778e][002a7792] 8bec mov ebp,esp
>>>>>>> ...[00001355][002a778e][002a7792] 8b4508 mov eax,[ebp+08]
>>>>>>> ...[00001358][002a778a][00001352] 50 push eax // push P
>>>>>>> ...[00001359][002a778a][00001352] 8b4d08 mov ecx,[ebp+08]
>>>>>>> ...[0000135c][002a7786][00001352] 51 push ecx // push P
>>>>>>> ...[0000135d][002a7782][00001362] e840feffff call 000011a2 // call H
>>>>>>> Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>>>>>>> H sees that P is calling the same function from the same machine
>>>>>>> address
>>>>>>> with identical parameters, twice in sequence. This is the infinite
>>>>>>> recursion non-halting behavior pattern.
>>>>>>> --
>>>>>>> Copyright 2022 Pete Olcott
>>>>>>>
>>>>>>> "Talent hits a target no one else can hit;
>>>>>>> Genius hits a target no one else can see."
>>>>>>> Arthur Schopenhauer
>>>>>>
>>>>>> This is not H (a halting decider).
>>>>> It does correctly decide the one "impossible" input basis of all of
>>>>> the
>>>>> proofs, thus refuting all of these proofs.
>>>>
>>>> "it" does not exist. Show your POOH.
>>>>
>>>> To refute HP, a H has to exist to refute. If H does not exist, no
>>>> real rebuttal exist.
>>> There is no need to show the hundreds of pages of source code for H
>>> (including the open source x86 emulator) or the hundreds of pages of
>>> execution trace of H because it is easily verified that:
>>
>> You choose to refute the conventional HP, and says that there is no
>> need to show
>> the hundreds of pages of H...,etc. How do you expect the reviewer/the
>> world
>> to verify POOH (a claim?) by 'claim'?
>>
>
> (a) Verify that the execution trace of P by H is correct by comparing
> this execution trace to the ax86 source-code of P.
>


Click here to read the complete article
Pages:1234
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor