Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Mathematicians practice absolute freedom. -- Henry Adams


devel / comp.theory / Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

SubjectAuthor
* Category errorMr Flibble
+* Category errorolcott
|`* Category errorRichard Damon
| `* Category errorolcott
|  `* Category errorRichard Damon
|   `* Category errorolcott
|    `* Category errorAndré G. Isaak
|     `* Category errorolcott
|      `* Category errorRichard Damon
|       +* Category errorAndré G. Isaak
|       |`* Category errorolcott
|       | `* Category errorAndré G. Isaak
|       |  +- Category errorRichard Damon
|       |  `* Category error [ --KEY_INSIGHT-- ]olcott
|       |   +* Category error [ --KEY_INSIGHT-- ]André G. Isaak
|       |   |`* Category error [ --KEY_INSIGHT-- ]olcott
|       |   | +* Category error [ --KEY_INSIGHT-- ]André G. Isaak
|       |   | |`* Category error [ --KEY_INSIGHT-- ]olcott
|       |   | | `* Category error [ --KEY_INSIGHT-- ]André G. Isaak
|       |   | |  `- Category error [ --KEY_INSIGHT-- ]olcott
|       |   | `* Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |   |  `* Category error [ --KEY_INSIGHT-- ]olcott
|       |   |   `* Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |   |    `* Category error [ --KEY_INSIGHT-- ]olcott
|       |   |     `* Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |   |      `* Category error [ --KEY_INSIGHT-- ]olcott
|       |   |       `- Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |   `* Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |    `* Category error [ --KEY_INSIGHT-- ]olcott
|       |     `* Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |      `* Category error [ --KEY_INSIGHT-- ]olcott
|       |       `* Category error [ --KEY_INSIGHT-- ]Richard Damon
|       |        `* Category error [ --KEY_INSIGHT-- ]olcott
|       |         `- Category error [ --KEY_INSIGHT-- ]Richard Damon
|       `* Category errorolcott
|        +* Category errorAndré G. Isaak
|        |`* Category errorolcott
|        | `* Category errorAndré G. Isaak
|        |  `* Category errorolcott
|        |   +* Category errorAndré G. Isaak
|        |   |`- Category errorolcott
|        |   `* Category errorRichard Damon
|        |    `* Category errorolcott
|        |     `* Category errorRichard Damon
|        |      `* Category errorolcott
|        |       `- Category errorRichard Damon
|        `- Category errorRichard Damon
+* Category errorwij
|`* Category errorMr Flibble
| `- Category errorolcott
`* Category errorMikko
 `* Category errorolcott
  +* Category errorRichard Damon
  |`* Category errorolcott
  | `- Category errorRichard Damon
  `* Category errorBen
   +* Category errorolcott
   |+- Category errorRichard Damon
   |`- Category errorBen
   `* Category error [ HEAD GAMES ]olcott
    +- Category error [ HEAD GAMES ]Richard Damon
    `* Category error [ HEAD GAMES ]Ben
     `* Category error [ HEAD GAMES ]olcott
      +- Category error [ HEAD GAMES ]Richard Damon
      +* Category error [ HEAD GAMES ]olcott
      |`* Category error [ HEAD GAMES ]Malcolm McLean
      | `* Category error [ HEAD GAMES ]olcott
      |  +- Category error [ HEAD GAMES ]Richard Damon
      |  `* Category error [ HEAD GAMES ]Malcolm McLean
      |   `* Category error [ HEAD GAMES ]olcott
      |    `- Category error [ HEAD GAMES ]Richard Damon
      `* Category error [ HEAD GAMES ]Ben
       `* Category error [ HEAD GAMES ]olcott
        +- Category error [ HEAD GAMES ]Richard Damon
        `* Category error [ HEAD GAMES ]Ben
         `* Category error [ HEAD GAMES ]olcott
          +- Category error [ HEAD GAMES ]Richard Damon
          +* Category error [ HEAD GAMES ] (clearer words)olcott
          |+- Category error [ HEAD GAMES ] (clearer words)Richard Damon
          |`* Category error [ HEAD GAMES ] (clearer words)Ben
          | `* Category error [ HEAD GAMES ] (clearer words)olcott
          |  +- Category error [ HEAD GAMES ] (clearer words)olcott
          |  +- Category error [ HEAD GAMES ] (clearer words)Richard Damon
          |  `* Category error [ HEAD GAMES ] (clearer words)Ben
          |   `* Category error [ HEAD GAMES ] (smart honest people would agree)olcott
          |    +- Category error [ HEAD GAMES ] (smart honest people would agree)Richard Damon
          |    `* Category error [ HEAD GAMES ] (smart honest people would agree)Ben
          |     +* Category error [ HEAD GAMES ] (smart honest people would agree)olcott
          |     |`* Category error [ HEAD GAMES ] (smart honest people would agree)Ben
          |     | `* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  +* Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]Ben
          |     |  |+* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  ||+* Category error [ HEAD GAMES ] (smart honest people would agree)[Richard Damon
          |     |  |||+* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  ||||`* Category error [ HEAD GAMES ] (smart honest people would agree)[Richard Damon
          |     |  |||| `* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  ||||  `- Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]Richard Damon
          |     |  |||`* Category error [ HEAD GAMES ] (smart honest people would agree)[Malcolm McLean
          |     |  ||| `* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  |||  `- Category error [ HEAD GAMES ] (smart honest people would agree)[Richard Damon
          |     |  ||`* Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]Ben
          |     |  |+* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  |+* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  |`* Category error [ HEAD GAMES ] (smart honest people would agree)[olcott
          |     |  `- Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]Richard Damon
          |     `* Category error [ HEAD GAMES ] (smart honest people would agree)olcott
          +* Category error [ HEAD GAMES ]Python
          `* Category error [ HEAD GAMES ]Ben

Pages:123456789101112
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 20 May 2022 22:13:18 -0500
Date: Fri, 20 May 2022 22:13:17 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<ctWdnS9Px7QHvRX_nZ2dnUU7_8xh4p2d@giganews.com>
<c4618654-0d3e-4e63-9c12-911f77194b5en@googlegroups.com>
<zeKdnXCrSbDJvhX_nZ2dnUU7_83NnZ2d@giganews.com>
<dff1371b-82bf-46bd-aaf2-cc82d01fef55n@googlegroups.com>
<BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com>
<2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 263
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-GjNdnh5W+2aHgm0NMZRar3wrv67WonJubb47gjcykCsh64cDENlRlwMUVCK0dzoAo9FO9AtBG+3LzmV!guTFNA0z/YhZsu4i26FCGOHhsYnWB6jeGkjHHqAdkqvy/CRVyRmoYYNjoNiXVh+ERcVnrQ68LHA=
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: 15892
 by: olcott - Sat, 21 May 2022 03:13 UTC

On 5/20/2022 10:06 PM, Dennis Bush wrote:
> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
>>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
>>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>
>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
>>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>
>>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
>>>>>>>>>
>>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
>>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
>>>>>>>> H(P,P).
>>>>>>>>
>>>>>>>> _P()
>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>
>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
>>>>>> OK then when the literal string of the machine code of H correctly
>>>>>> emulates
>>>>>
>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
>>>> H is at machine address 00000826 every other variation is a dishonest
>>>> dodge away from the actual question.
>>>
>>> And since the fixed H is programmed to abort
>> This is not true and we are not yet discussing that aspect of it yet.
>
> It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
>


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<M5ZhK.5735$5fVf.3950@fx09.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx09.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<c4618654-0d3e-4e63-9c12-911f77194b5en@googlegroups.com>
<zeKdnXCrSbDJvhX_nZ2dnUU7_83NnZ2d@giganews.com>
<dff1371b-82bf-46bd-aaf2-cc82d01fef55n@googlegroups.com>
<BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com>
<2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 350
Message-ID: <M5ZhK.5735$5fVf.3950@fx09.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: Fri, 20 May 2022 23:35:07 -0400
X-Received-Bytes: 17561
 by: Richard Damon - Sat, 21 May 2022 03:35 UTC

On 5/20/22 11:13 PM, olcott wrote:
> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six
>>>>>>>>>>>>>>>>>>>>>>>>>>> months
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if
>>>>>>>>>>>>>>>>>>>>>>>>>> only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong
>>>>>>>>>>>>>>>>>>>>>>>>>> because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no
>>>>>>>>>>>>>>>>>>>>>>>>> lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the
>>>>>>>>>>>>>>>>>>>>>>>>> simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses
>>>>>>>>>>>>>>>>>>>>>>> the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong
>>>>>>>>>>>>>>>>>>>>>> or irrelevent you should have no problem
>>>>>>>>>>>>>>>>>>>>>> explaining why without just saying "strawman".
>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the
>>>>>>>>>>>>>>>>>>>>> machine language of P
>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific
>>>>>>>>>>>>>>>>>>>>> finite string of
>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0
>>>>>>>>>>>>>>>>>>>> is correct,
>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I
>>>>>>>>>>>>>>>>>>> prove the
>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P)
>>>>>>>>>>>>>>>>>> is correct is whether P(P) halts, *by definition*.
>>>>>>>>>>>>>>>>> Not for the specific machine language that I am
>>>>>>>>>>>>>>>>> referring to.
>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable
>>>>>>>>>>>>>>>>> liar mode.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the
>>>>>>>>>>>>>>>>> input to H(P,P)
>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves
>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>> Not when we are talking about C functions and x86
>>>>>>>>>>>>>>> machine-code Jackass.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H
>>>>>>>>>>>>>> is computing something other that the halting function
>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>
>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the
>>>>>>>>>>> halt status
>>>>>>>>>>> of the machine language of P that is passed to H on the stack
>>>>>>>>>>> as a pair
>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>
>>>>>>>>>> If you're referring to *just* the function P, it doesn't have
>>>>>>>>>> a halt status because it's not a complete program.
>>>>>>>>>>
>>>>>>>>> When we stipulate that the input to H(P,P) only halts when its
>>>>>>>>> correct
>>>>>>>>> simulation reaches its machine address of [000009f0] otherwise
>>>>>>>>> it is
>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the
>>>>>>>>> input to
>>>>>>>>> H(P,P).
>>>>>>>>>
>>>>>>>>> _P()
>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>
>>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct
>>>>>>>> simulation of this input is done Hb(P,P) which does in fact
>>>>>>>> reach a final state. Therefore H(P,P)==0 is wrong.
>>>>>>> OK then when the literal string of the machine code of H correctly
>>>>>>> emulates
>>>>>>
>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state
>>>>>> and returning 1.
>>>>> H is at machine address 00000826 every other variation is a dishonest
>>>>> dodge away from the actual question.
>>>>
>>>> And since the fixed H is programmed to abort
>>> This is not true and we are not yet discussing that aspect of it yet.
>>
>> It must be, otherwise you have nothing to decide on.  Remember, P is a
>> *complete* program, which means the H is called must be fully defined
>> and fixed.
>>
>
> It is ridiculously stupid to say that a halt decider has a fixed behavior.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:620a:2886:b0:699:bab7:ae78 with SMTP id j6-20020a05620a288600b00699bab7ae78mr7953931qkp.618.1653104256262;
Fri, 20 May 2022 20:37:36 -0700 (PDT)
X-Received: by 2002:a0d:d801:0:b0:2fe:feb2:242a with SMTP id
a1-20020a0dd801000000b002fefeb2242amr13365052ywe.127.1653104256078; Fri, 20
May 2022 20:37: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: Fri, 20 May 2022 20:37:35 -0700 (PDT)
In-Reply-To: <oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@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: <20220514170555.00004550@reddwarf.jmc> <ctWdnS9Px7QHvRX_nZ2dnUU7_8xh4p2d@giganews.com>
<c4618654-0d3e-4e63-9c12-911f77194b5en@googlegroups.com> <zeKdnXCrSbDJvhX_nZ2dnUU7_83NnZ2d@giganews.com>
<dff1371b-82bf-46bd-aaf2-cc82d01fef55n@googlegroups.com> <BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com> <2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com> <16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com> <j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com> <k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com> <VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com> <DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com> <oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
Subject: Re: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 03:37:36 +0000
Content-Type: text/plain; charset="UTF-8"
 by: Dennis Bush - Sat, 21 May 2022 03:37 UTC

On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
> On 5/20/2022 10:06 PM, Dennis Bush wrote:
> > On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
> >> On 5/20/2022 9:32 PM, Dennis Bush wrote:
> >>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
> >>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
> >>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
> >>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
> >>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
> >>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
> >>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
> >>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
> >>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
> >>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
> >>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
> >>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
> >>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
> >>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
> >>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
> >>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
> >>>>>>>>>>>>>>>>>>>> machine language named H.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
> >>>>>>>>>>>>>>>>>> More than that.
> >>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
> >>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
> >>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
> >>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
> >>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
> >>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
> >>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
> >>>>>>>>>>>
> >>>>>>>>>>> Only for something that is not the halting problem.
> >>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
> >>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
> >>>>>>>>>> of pointers to the literal string of P?
> >>>>>>>>>
> >>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
> >>>>>>>>>
> >>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
> >>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
> >>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
> >>>>>>>> H(P,P).
> >>>>>>>>
> >>>>>>>> _P()
> >>>>>>>> [000009d6](01) 55 push ebp
> >>>>>>>> [000009d7](02) 8bec mov ebp,esp
> >>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>> [000009dc](01) 50 push eax // push P
> >>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>> [000009e0](01) 51 push ecx // push P
> >>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
> >>>>>>>> [000009e6](03) 83c408 add esp,+08
> >>>>>>>> [000009e9](02) 85c0 test eax,eax
> >>>>>>>> [000009eb](02) 7402 jz 000009ef
> >>>>>>>> [000009ed](02) ebfe jmp 000009ed
> >>>>>>>> [000009ef](01) 5d pop ebp
> >>>>>>>> [000009f0](01) c3 ret // Final state
> >>>>>>>> Size in bytes:(0027) [000009f0]
> >>>>>>>
> >>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
> >>>>>> OK then when the literal string of the machine code of H correctly
> >>>>>> emulates
> >>>>>
> >>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
> >>>> H is at machine address 00000826 every other variation is a dishonest
> >>>> dodge away from the actual question.
> >>>
> >>> And since the fixed H is programmed to abort
> >> This is not true and we are not yet discussing that aspect of it yet.
> >
> > It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
> >
> It is ridiculously stupid to say that a halt decider has a fixed behavior.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 20 May 2022 22:42:48 -0500
Date: Fri, 20 May 2022 22:42:46 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<zeKdnXCrSbDJvhX_nZ2dnUU7_83NnZ2d@giganews.com>
<dff1371b-82bf-46bd-aaf2-cc82d01fef55n@googlegroups.com>
<BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com>
<2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 176
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-l5DzlqHS3RI0Bbwo7oZC6m1zMwj/aaWFpKOxkkGQ3O9aB4qfBZli5tbcFO/QVBUgqiF1OCjj3mzRIkQ!p+MOVMrM6UWRczcFZiirRKEFbMyhFdlaVdHLDK2eV9xsVTYMw1GDdyQPaYrdsk5BU9EXi+L/XI0=
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: 11394
 by: olcott - Sat, 21 May 2022 03:42 UTC

On 5/20/2022 10:37 PM, Dennis Bush wrote:
> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
>>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
>>>>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>
>>>>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
>>>>>>>>>>>
>>>>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
>>>>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
>>>>>>>>>> H(P,P).
>>>>>>>>>>
>>>>>>>>>> _P()
>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>
>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
>>>>>>>> OK then when the literal string of the machine code of H correctly
>>>>>>>> emulates
>>>>>>>
>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
>>>>>> H is at machine address 00000826 every other variation is a dishonest
>>>>>> dodge away from the actual question.
>>>>>
>>>>> And since the fixed H is programmed to abort
>>>> This is not true and we are not yet discussing that aspect of it yet.
>>>
>>> It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
>>>
>> It is ridiculously stupid to say that a halt decider has a fixed behavior.
>
> You have it backwards. It is ridiculously stupid to say that *any* computation, *including* a halt decider, does NOT have a fixed behavior. That's how a given input always gives the same output.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ad4:4208:0:b0:461:d262:7842 with SMTP id k8-20020ad44208000000b00461d2627842mr10241952qvp.113.1653105393029;
Fri, 20 May 2022 20:56:33 -0700 (PDT)
X-Received: by 2002:a25:ca83:0:b0:64f:75d8:9219 with SMTP id
a125-20020a25ca83000000b0064f75d89219mr3949706ybg.251.1653105392870; Fri, 20
May 2022 20:56:32 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Fri, 20 May 2022 20:56:32 -0700 (PDT)
In-Reply-To: <Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@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: <20220514170555.00004550@reddwarf.jmc> <zeKdnXCrSbDJvhX_nZ2dnUU7_83NnZ2d@giganews.com>
<dff1371b-82bf-46bd-aaf2-cc82d01fef55n@googlegroups.com> <BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com> <2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com> <16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com> <j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com> <k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com> <VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com> <DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com> <oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com> <Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
Subject: Re: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 03:56:33 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 12493
 by: Dennis Bush - Sat, 21 May 2022 03:56 UTC

On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
> On 5/20/2022 10:37 PM, Dennis Bush wrote:
> > On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
> >> On 5/20/2022 10:06 PM, Dennis Bush wrote:
> >>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
> >>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
> >>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
> >>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
> >>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
> >>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
> >>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
> >>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
> >>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
> >>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
> >>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
> >>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
> >>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
> >>>>>>>>>>>>>>>>>>>>>> machine language named H.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
> >>>>>>>>>>>>>>>>>>>> More than that.
> >>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
> >>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
> >>>>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
> >>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
> >>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
> >>>>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
> >>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Only for something that is not the halting problem.
> >>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
> >>>>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
> >>>>>>>>>>>> of pointers to the literal string of P?
> >>>>>>>>>>>
> >>>>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
> >>>>>>>>>>>
> >>>>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
> >>>>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
> >>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
> >>>>>>>>>> H(P,P).
> >>>>>>>>>>
> >>>>>>>>>> _P()
> >>>>>>>>>> [000009d6](01) 55 push ebp
> >>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
> >>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>> [000009dc](01) 50 push eax // push P
> >>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>> [000009e0](01) 51 push ecx // push P
> >>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
> >>>>>>>>>> [000009e6](03) 83c408 add esp,+08
> >>>>>>>>>> [000009e9](02) 85c0 test eax,eax
> >>>>>>>>>> [000009eb](02) 7402 jz 000009ef
> >>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
> >>>>>>>>>> [000009ef](01) 5d pop ebp
> >>>>>>>>>> [000009f0](01) c3 ret // Final state
> >>>>>>>>>> Size in bytes:(0027) [000009f0]
> >>>>>>>>>
> >>>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
> >>>>>>>> OK then when the literal string of the machine code of H correctly
> >>>>>>>> emulates
> >>>>>>>
> >>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
> >>>>>> H is at machine address 00000826 every other variation is a dishonest
> >>>>>> dodge away from the actual question.
> >>>>>
> >>>>> And since the fixed H is programmed to abort
> >>>> This is not true and we are not yet discussing that aspect of it yet..
> >>>
> >>> It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
> >>>
> >> It is ridiculously stupid to say that a halt decider has a fixed behavior.
> >
> > You have it backwards. It is ridiculously stupid to say that *any* computation, *including* a halt decider, does NOT have a fixed behavior. That's how a given input always gives the same output.
> It has a different behavior for every input, nitwit.
> How stupid can you get?


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<crZhK.216$elob.209@fx43.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx43.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<dff1371b-82bf-46bd-aaf2-cc82d01fef55n@googlegroups.com>
<BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com>
<2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 237
Message-ID: <crZhK.216$elob.209@fx43.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Fri, 20 May 2022 23:58:00 -0400
X-Received-Bytes: 12623
 by: Richard Damon - Sat, 21 May 2022 03:58 UTC

On 5/20/22 11:42 PM, olcott wrote:
> On 5/20/2022 10:37 PM, Dennis Bush wrote:
>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> months
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no
>>>>>>>>>>>>>>>>>>>>>>>>>>> lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that
>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses
>>>>>>>>>>>>>>>>>>>>>>>>> the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either
>>>>>>>>>>>>>>>>>>>>>>>> wrong or irrelevent you should have no problem
>>>>>>>>>>>>>>>>>>>>>>>> explaining why without just saying "strawman".
>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the
>>>>>>>>>>>>>>>>>>>>>>> machine language of P
>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific
>>>>>>>>>>>>>>>>>>>>>>> finite string of
>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0
>>>>>>>>>>>>>>>>>>>>>> is correct,
>>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and
>>>>>>>>>>>>>>>>>>>>> I prove the
>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P)
>>>>>>>>>>>>>>>>>>>> is correct is whether P(P) halts, *by definition*.
>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am
>>>>>>>>>>>>>>>>>>> referring to.
>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable
>>>>>>>>>>>>>>>>>>> liar mode.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that
>>>>>>>>>>>>>>>>>>> the input to H(P,P)
>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves
>>>>>>>>>>>>>>>>>>> otherwise.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86
>>>>>>>>>>>>>>>>> machine-code Jackass.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H
>>>>>>>>>>>>>>>> is computing something other that the halting function
>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the
>>>>>>>>>>>>> halt status
>>>>>>>>>>>>> of the machine language of P that is passed to H on the
>>>>>>>>>>>>> stack as a pair
>>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>>
>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't
>>>>>>>>>>>> have a halt status because it's not a complete program.
>>>>>>>>>>>>
>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts when
>>>>>>>>>>> its correct
>>>>>>>>>>> simulation reaches its machine address of [000009f0]
>>>>>>>>>>> otherwise it is
>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the
>>>>>>>>>>> input to
>>>>>>>>>>> H(P,P).
>>>>>>>>>>>
>>>>>>>>>>> _P()
>>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>>
>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A
>>>>>>>>>> correct simulation of this input is done Hb(P,P) which does in
>>>>>>>>>> fact reach a final state. Therefore H(P,P)==0 is wrong.
>>>>>>>>> OK then when the literal string of the machine code of H correctly
>>>>>>>>> emulates
>>>>>>>>
>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final
>>>>>>>> state and returning 1.
>>>>>>> H is at machine address 00000826 every other variation is a
>>>>>>> dishonest
>>>>>>> dodge away from the actual question.
>>>>>>
>>>>>> And since the fixed H is programmed to abort
>>>>> This is not true and we are not yet discussing that aspect of it yet.
>>>>
>>>> It must be, otherwise you have nothing to decide on. Remember, P is
>>>> a *complete* program, which means the H is called must be fully
>>>> defined and fixed.
>>>>
>>> It is ridiculously stupid to say that a halt decider has a fixed
>>> behavior.
>>
>> You have it backwards.  It is ridiculously stupid to say that *any*
>> computation, *including* a halt decider, does NOT have a fixed
>> behavior.  That's how a given input always gives the same output.
>
> It has a different behavior for every input, nitwit.
> How stupid can you get?
>
>
>>>
>>> given an input of the function domain it can return the corresponding
>>> output. https://en.wikipedia.org/wiki/Computable_function
>>
>> And for the halting function, its domain is a turing machine M and its
>> input w, and its output is: accept if M applied to w halts, and reject
>> if M applied to w does not halt.  And the question of the halting
>> problem is: Is the halting function computable?
>>
>
> The domain of H is this finite string:
> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>
> Do you have attention deficit disorder that scrambles your attention
> span so that you can't stay focused on H(P,P) ???
>


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 20 May 2022 23:02:26 -0500
Date: Fri, 20 May 2022 23:02:25 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com>
<2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>
Lines: 188
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-drZI6SrB43PZATgWlnMPVMGo2/Hxzz+alTcfA2fmhLiCbRGFrYVq62MSOv2QyMvOUOvf0wLjlWW/3+S!S9tyZTDTxkSLkizWrNiLiUvMu3M+Sq/iM/lIcY09+fqkkK7Zr8c4xZgbq3Op60HGG+RaBz7LvaA=
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: 12348
 by: olcott - Sat, 21 May 2022 04:02 UTC

On 5/20/2022 10:56 PM, Dennis Bush wrote:
> On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
>> On 5/20/2022 10:37 PM, Dennis Bush wrote:
>>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
>>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
>>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
>>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
>>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
>>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
>>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
>>>>>>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
>>>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
>>>>>>>>>>>>>
>>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
>>>>>>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
>>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
>>>>>>>>>>>> H(P,P).
>>>>>>>>>>>>
>>>>>>>>>>>> _P()
>>>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>>>
>>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
>>>>>>>>>> OK then when the literal string of the machine code of H correctly
>>>>>>>>>> emulates
>>>>>>>>>
>>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
>>>>>>>> H is at machine address 00000826 every other variation is a dishonest
>>>>>>>> dodge away from the actual question.
>>>>>>>
>>>>>>> And since the fixed H is programmed to abort
>>>>>> This is not true and we are not yet discussing that aspect of it yet.
>>>>>
>>>>> It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
>>>>>
>>>> It is ridiculously stupid to say that a halt decider has a fixed behavior.
>>>
>>> You have it backwards. It is ridiculously stupid to say that *any* computation, *including* a halt decider, does NOT have a fixed behavior. That's how a given input always gives the same output.
>> It has a different behavior for every input, nitwit.
>> How stupid can you get?
>
> Perhaps that was worded incorrectly. The *algorithm* of a computation is fixed, which in turn means its behavior is fixed for a given input.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:ac8:58c3:0:b0:2f9:2356:d21f with SMTP id u3-20020ac858c3000000b002f92356d21fmr3060547qta.265.1653106232946;
Fri, 20 May 2022 21:10:32 -0700 (PDT)
X-Received: by 2002:a05:6902:12c6:b0:644:d4fd:f149 with SMTP id
j6-20020a05690212c600b00644d4fdf149mr13213248ybu.347.1653106232729; Fri, 20
May 2022 21:10:32 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Fri, 20 May 2022 21:10:32 -0700 (PDT)
In-Reply-To: <D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@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: <20220514170555.00004550@reddwarf.jmc> <BeidnQh8xsG-uxX_nZ2dnUU7_8zNnZ2d@giganews.com>
<309e8113-7c56-4060-9e01-cd47066145adn@googlegroups.com> <2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com> <16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com> <j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com> <k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com> <VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com> <DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com> <oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com> <Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com> <D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
Subject: Re: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
From: dbush.mo...@gmail.com (Dennis Bush)
Injection-Date: Sat, 21 May 2022 04:10:32 +0000
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Received-Bytes: 13416
 by: Dennis Bush - Sat, 21 May 2022 04:10 UTC

On Saturday, May 21, 2022 at 12:02:33 AM UTC-4, olcott wrote:
> On 5/20/2022 10:56 PM, Dennis Bush wrote:
> > On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
> >> On 5/20/2022 10:37 PM, Dennis Bush wrote:
> >>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
> >>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
> >>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
> >>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
> >>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
> >>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
> >>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
> >>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
> >>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
> >>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
> >>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
> >>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
> >>>>>>>>>>>>>>>>>>>>>> More than that.
> >>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
> >>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
> >>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
> >>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
> >>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
> >>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
> >>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Only for something that is not the halting problem.
> >>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
> >>>>>>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
> >>>>>>>>>>>>>> of pointers to the literal string of P?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
> >>>>>>>>>>>>>
> >>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
> >>>>>>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
> >>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
> >>>>>>>>>>>> H(P,P).
> >>>>>>>>>>>>
> >>>>>>>>>>>> _P()
> >>>>>>>>>>>> [000009d6](01) 55 push ebp
> >>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
> >>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>> [000009dc](01) 50 push eax // push P
> >>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
> >>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
> >>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
> >>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
> >>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
> >>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
> >>>>>>>>>>>> [000009ef](01) 5d pop ebp
> >>>>>>>>>>>> [000009f0](01) c3 ret // Final state
> >>>>>>>>>>>> Size in bytes:(0027) [000009f0]
> >>>>>>>>>>>
> >>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
> >>>>>>>>>> OK then when the literal string of the machine code of H correctly
> >>>>>>>>>> emulates
> >>>>>>>>>
> >>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
> >>>>>>>> H is at machine address 00000826 every other variation is a dishonest
> >>>>>>>> dodge away from the actual question.
> >>>>>>>
> >>>>>>> And since the fixed H is programmed to abort
> >>>>>> This is not true and we are not yet discussing that aspect of it yet.
> >>>>>
> >>>>> It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
> >>>>>
> >>>> It is ridiculously stupid to say that a halt decider has a fixed behavior.
> >>>
> >>> You have it backwards. It is ridiculously stupid to say that *any* computation, *including* a halt decider, does NOT have a fixed behavior. That's how a given input always gives the same output.
> >> It has a different behavior for every input, nitwit.
> >> How stupid can you get?
> >
> > Perhaps that was worded incorrectly. The *algorithm* of a computation is fixed, which in turn means its behavior is fixed for a given input.
> Heh that is great. Yeah !!!
> I gave you feedback and we came to mutual agreement.
> >
> >>>>
> >>>> given an input of the function domain it can return the corresponding
> >>>> output. https://en.wikipedia.org/wiki/Computable_function
> >>>
> >>> And for the halting function, its domain is a turing machine M and its input w, and its output is: accept if M applied to w halts, and reject if M applied to w does not halt. And the question of the halting problem is: Is the halting function computable?
> >>>
> >> The domain of H is this finite string:
> >> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
> >
> > Which is not a complete program. So if H's domain is not complete programs, then by definition it is not a halt decider.
> OK then call it a halt determiner.
> None-the-less H(P,P)==0 is correct in such an obvious way that if you
> were unbiased you would have agreed long ago.
> >>
> >> Do you have attention deficit disorder that scrambles your attention
> >> span so that you can't stay focused on H(P,P) ???
> >>>>
> >>>> In any case I am only talking about the simulation of the input to
> >>>> H(P,P). Are you freaking stupid of what?
> >>>>> Otherwise what you're saying is:
> >>>>>
> >>>>> Since H1(P1,P1)==0,
> >>>>> and H2(P2,P2)==0,
> >>>>> and H3(P3,P3)==0,
> >>>>> and H4(P4,P4)==0,
> >>>>> and H5(P5,P5)==0,
> >>>>> ....
> >>>>> and Hn(Pn,Pn) does not halt,
> >>>>> Then for any i, Hi(Pi,Pi) == 0 is correct
> >>>>>
> >>>>> These P's are all separate and distinct computations having nothing to do with each other.
> >>>>>
> >>>> This is the P that I am referring to knucklehead:
> >>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
> >>>
> >>> So since you aren't specifying H, then you do in fact mean:
> >> I mean that halt decider that P calls.
> >
> > So in other words, since you haven't fixed the algorithm of H:
> The algorithm of H is fixed.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Fri, 20 May 2022 23:15:23 -0500
Date: Fri, 20 May 2022 23:15:21 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<2aadndCyHb-GshX_nZ2dnUU7_83NnZ2d@giganews.com>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
<D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>
<d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 181
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-WknM5BbRaXPoknoDiwHZrfdbgqFIFkDgi8RvhlM5MshvdHgzqq7V4HE5ge2HX37JrhNmRyK8wTpNkck!aiFiDjQ+rzhmkpbhMZDDagsAUZnYOZIjCw+/HNUp7c0JzhvcY5g5+SuzQAwOOC1H7N6kkz4OttQ=
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: 12770
 by: olcott - Sat, 21 May 2022 04:15 UTC

On 5/20/2022 11:10 PM, Dennis Bush wrote:
> On Saturday, May 21, 2022 at 12:02:33 AM UTC-4, olcott wrote:
>> On 5/20/2022 10:56 PM, Dennis Bush wrote:
>>> On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
>>>> On 5/20/2022 10:37 PM, Dennis Bush wrote:
>>>>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>>>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either wrong or irrelevent you should have no problem explaining why without just saying "strawman".
>>>>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of the machine language of P
>>>>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100% specific finite string of
>>>>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct and I prove the
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that criteria.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of H(P,P) is correct is whether P(P) halts, *by definition*.
>>>>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am referring to.
>>>>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in despicable liar mode.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace proves otherwise.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86 machine-code Jackass.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Then you're not talking about the halting problem, and H is computing something other that the halting function
>>>>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes the halt status
>>>>>>>>>>>>>>>> of the machine language of P that is passed to H on the stack as a pair
>>>>>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't have a halt status because it's not a complete program.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts when its correct
>>>>>>>>>>>>>> simulation reaches its machine address of [000009f0] otherwise it is
>>>>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of the input to
>>>>>>>>>>>>>> H(P,P).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>>>>>
>>>>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A correct simulation of this input is done Hb(P,P) which does in fact reach a final state. Therefore H(P,P)==0 is wrong.
>>>>>>>>>>>> OK then when the literal string of the machine code of H correctly
>>>>>>>>>>>> emulates
>>>>>>>>>>>
>>>>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final state and returning 1.
>>>>>>>>>> H is at machine address 00000826 every other variation is a dishonest
>>>>>>>>>> dodge away from the actual question.
>>>>>>>>>
>>>>>>>>> And since the fixed H is programmed to abort
>>>>>>>> This is not true and we are not yet discussing that aspect of it yet.
>>>>>>>
>>>>>>> It must be, otherwise you have nothing to decide on. Remember, P is a *complete* program, which means the H is called must be fully defined and fixed.
>>>>>>>
>>>>>> It is ridiculously stupid to say that a halt decider has a fixed behavior.
>>>>>
>>>>> You have it backwards. It is ridiculously stupid to say that *any* computation, *including* a halt decider, does NOT have a fixed behavior. That's how a given input always gives the same output.
>>>> It has a different behavior for every input, nitwit.
>>>> How stupid can you get?
>>>
>>> Perhaps that was worded incorrectly. The *algorithm* of a computation is fixed, which in turn means its behavior is fixed for a given input.
>> Heh that is great. Yeah !!!
>> I gave you feedback and we came to mutual agreement.
>>>
>>>>>>
>>>>>> given an input of the function domain it can return the corresponding
>>>>>> output. https://en.wikipedia.org/wiki/Computable_function
>>>>>
>>>>> And for the halting function, its domain is a turing machine M and its input w, and its output is: accept if M applied to w halts, and reject if M applied to w does not halt. And the question of the halting problem is: Is the halting function computable?
>>>>>
>>>> The domain of H is this finite string:
>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>
>>> Which is not a complete program. So if H's domain is not complete programs, then by definition it is not a halt decider.
>> OK then call it a halt determiner.
>> None-the-less H(P,P)==0 is correct in such an obvious way that if you
>> were unbiased you would have agreed long ago.
>>>>
>>>> Do you have attention deficit disorder that scrambles your attention
>>>> span so that you can't stay focused on H(P,P) ???
>>>>>>
>>>>>> In any case I am only talking about the simulation of the input to
>>>>>> H(P,P). Are you freaking stupid of what?
>>>>>>> Otherwise what you're saying is:
>>>>>>>
>>>>>>> Since H1(P1,P1)==0,
>>>>>>> and H2(P2,P2)==0,
>>>>>>> and H3(P3,P3)==0,
>>>>>>> and H4(P4,P4)==0,
>>>>>>> and H5(P5,P5)==0,
>>>>>>> ....
>>>>>>> and Hn(Pn,Pn) does not halt,
>>>>>>> Then for any i, Hi(Pi,Pi) == 0 is correct
>>>>>>>
>>>>>>> These P's are all separate and distinct computations having nothing to do with each other.
>>>>>>>
>>>>>> This is the P that I am referring to knucklehead:
>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>
>>>>> So since you aren't specifying H, then you do in fact mean:
>>>> I mean that halt decider that P calls.
>>>
>>> So in other words, since you haven't fixed the algorithm of H:
>> The algorithm of H is fixed.
>
> Alright, so since the fixed algorithm of H aborts,


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<t83iK.2585$vAW9.2416@fx10.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx10.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
<D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>
<d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
<a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 264
Message-ID: <t83iK.2585$vAW9.2416@fx10.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: Sat, 21 May 2022 06:27:37 -0400
X-Received-Bytes: 14937
 by: Richard Damon - Sat, 21 May 2022 10:27 UTC

On 5/21/22 12:15 AM, olcott wrote:
> On 5/20/2022 11:10 PM, Dennis Bush wrote:
>> On Saturday, May 21, 2022 at 12:02:33 AM UTC-4, olcott wrote:
>>> On 5/20/2022 10:56 PM, Dennis Bush wrote:
>>>> On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
>>>>> On 5/20/2022 10:37 PM, Dennis Bush wrote:
>>>>>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>>>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>>>>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>>>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> six months
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either
>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong or irrelevent you should have no
>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem explaining why without just saying
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "strawman".
>>>>>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine language of P
>>>>>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100%
>>>>>>>>>>>>>>>>>>>>>>>>>>> specific finite string of
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct
>>>>>>>>>>>>>>>>>>>>>>>>> and I prove the
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that
>>>>>>>>>>>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is correct is whether P(P) halts, *by
>>>>>>>>>>>>>>>>>>>>>>>> definition*.
>>>>>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am
>>>>>>>>>>>>>>>>>>>>>>> referring to.
>>>>>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in
>>>>>>>>>>>>>>>>>>>>>>> despicable liar mode.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat
>>>>>>>>>>>>>>>>>>>>>>> that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace
>>>>>>>>>>>>>>>>>>>>>>> proves otherwise.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86
>>>>>>>>>>>>>>>>>>>>> machine-code Jackass.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Then you're not talking about the halting problem,
>>>>>>>>>>>>>>>>>>>> and H is computing something other that the halting
>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes
>>>>>>>>>>>>>>>>> the halt status
>>>>>>>>>>>>>>>>> of the machine language of P that is passed to H on the
>>>>>>>>>>>>>>>>> stack as a pair
>>>>>>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't
>>>>>>>>>>>>>>>> have a halt status because it's not a complete program.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts
>>>>>>>>>>>>>>> when its correct
>>>>>>>>>>>>>>> simulation reaches its machine address of [000009f0]
>>>>>>>>>>>>>>> otherwise it is
>>>>>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of
>>>>>>>>>>>>>>> the input to
>>>>>>>>>>>>>>> H(P,P).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A
>>>>>>>>>>>>>> correct simulation of this input is done Hb(P,P) which
>>>>>>>>>>>>>> does in fact reach a final state. Therefore H(P,P)==0 is
>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>> OK then when the literal string of the machine code of H
>>>>>>>>>>>>> correctly
>>>>>>>>>>>>> emulates
>>>>>>>>>>>>
>>>>>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final
>>>>>>>>>>>> state and returning 1.
>>>>>>>>>>> H is at machine address 00000826 every other variation is a
>>>>>>>>>>> dishonest
>>>>>>>>>>> dodge away from the actual question.
>>>>>>>>>>
>>>>>>>>>> And since the fixed H is programmed to abort
>>>>>>>>> This is not true and we are not yet discussing that aspect of
>>>>>>>>> it yet.
>>>>>>>>
>>>>>>>> It must be, otherwise you have nothing to decide on. Remember, P
>>>>>>>> is a *complete* program, which means the H is called must be
>>>>>>>> fully defined and fixed.
>>>>>>>>
>>>>>>> It is ridiculously stupid to say that a halt decider has a fixed
>>>>>>> behavior.
>>>>>>
>>>>>> You have it backwards. It is ridiculously stupid to say that *any*
>>>>>> computation, *including* a halt decider, does NOT have a fixed
>>>>>> behavior. That's how a given input always gives the same output.
>>>>> It has a different behavior for every input, nitwit.
>>>>> How stupid can you get?
>>>>
>>>> Perhaps that was worded incorrectly. The *algorithm* of a
>>>> computation is fixed, which in turn means its behavior is fixed for
>>>> a given input.
>>> Heh that is great. Yeah !!!
>>> I gave you feedback and we came to mutual agreement.
>>>>
>>>>>>>
>>>>>>> given an input of the function domain it can return the
>>>>>>> corresponding
>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function
>>>>>>
>>>>>> And for the halting function, its domain is a turing machine M and
>>>>>> its input w, and its output is: accept if M applied to w halts,
>>>>>> and reject if M applied to w does not halt. And the question of
>>>>>> the halting problem is: Is the halting function computable?
>>>>>>
>>>>> The domain of H is this finite string:
>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>
>>>> Which is not a complete program. So if H's domain is not complete
>>>> programs, then by definition it is not a halt decider.
>>> OK then call it a halt determiner.
>>> None-the-less H(P,P)==0 is correct in such an obvious way that if you
>>> were unbiased you would have agreed long ago.
>>>>>
>>>>> Do you have attention deficit disorder that scrambles your attention
>>>>> span so that you can't stay focused on H(P,P) ???
>>>>>>>
>>>>>>> In any case I am only talking about the simulation of the input to
>>>>>>> H(P,P). Are you freaking stupid of what?
>>>>>>>> Otherwise what you're saying is:
>>>>>>>>
>>>>>>>> Since H1(P1,P1)==0,
>>>>>>>> and H2(P2,P2)==0,
>>>>>>>> and H3(P3,P3)==0,
>>>>>>>> and H4(P4,P4)==0,
>>>>>>>> and H5(P5,P5)==0,
>>>>>>>> ....
>>>>>>>> and Hn(Pn,Pn) does not halt,
>>>>>>>> Then for any i, Hi(Pi,Pi) == 0 is correct
>>>>>>>>
>>>>>>>> These P's are all separate and distinct computations having
>>>>>>>> nothing to do with each other.
>>>>>>>>
>>>>>>> This is the P that I am referring to knucklehead:
>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>
>>>>>> So since you aren't specifying H, then you do in fact mean:
>>>>> I mean that halt decider that P calls.
>>>>
>>>> So in other words, since you haven't fixed the algorithm of H:
>>> The algorithm of H is fixed.
>>
>> Alright, so since the fixed algorithm of H aborts,
>
> No we won't.
> With your ADD we have to stay sharply focused on a single point.
>
> We are ONLY evaluating whether or not the simulation of the input to
> H(P,P) is correct. I have been telling you this for many messages now
> and you keep drifting off topic.
>
>


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<fc2034d8-96e7-4914-bc46-f5ffabc51ab8n@googlegroups.com>

 copy mid

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

 copy link   Newsgroups: comp.theory
X-Received: by 2002:a05:6214:14aa:b0:461:c3eb:c3c9 with SMTP id bo10-20020a05621414aa00b00461c3ebc3c9mr12005968qvb.88.1653153893274;
Sat, 21 May 2022 10:24:53 -0700 (PDT)
X-Received: by 2002:a25:e0cb:0:b0:64f:7b57:8a6a with SMTP id
x194-20020a25e0cb000000b0064f7b578a6amr4989054ybg.24.1653153893000; Sat, 21
May 2022 10:24:53 -0700 (PDT)
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.theory
Date: Sat, 21 May 2022 10:24:52 -0700 (PDT)
In-Reply-To: <t83iK.2585$vAW9.2416@fx10.iad>
Injection-Info: google-groups.googlegroups.com; posting-host=2a00:23a8:400a:5601:a0a0:c8b:1401:cdd7;
posting-account=Dz2zqgkAAADlK5MFu78bw3ab-BRFV4Qn
NNTP-Posting-Host: 2a00:23a8:400a:5601:a0a0:c8b:1401:cdd7
References: <20220514170555.00004550@reddwarf.jmc> <f76db3cc-e429-4cfd-be35-79f08228e4d2n@googlegroups.com>
<16WdnXURO7I8pRX_nZ2dnUU7_83NnZ2d@giganews.com> <b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com> <8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com> <e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com> <9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com> <80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com> <3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com> <78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
<D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com> <d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
<a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com> <t83iK.2585$vAW9.2416@fx10.iad>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <fc2034d8-96e7-4914-bc46-f5ffabc51ab8n@googlegroups.com>
Subject: Re: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
From: malcolm....@gmail.com (Malcolm McLean)
Injection-Date: Sat, 21 May 2022 17:24:53 +0000
Content-Type: text/plain; charset="UTF-8"
X-Received-Bytes: 16669
 by: Malcolm McLean - Sat, 21 May 2022 17:24 UTC

On Saturday, 21 May 2022 at 11:27:41 UTC+1, richar...@gmail.com wrote:
> On 5/21/22 12:15 AM, olcott wrote:
> > On 5/20/2022 11:10 PM, Dennis Bush wrote:
> >> On Saturday, May 21, 2022 at 12:02:33 AM UTC-4, olcott wrote:
> >>> On 5/20/2022 10:56 PM, Dennis Bush wrote:
> >>>> On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
> >>>>> On 5/20/2022 10:37 PM, Dennis Bush wrote:
> >>>>>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
> >>>>>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
> >>>>>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
> >>>>>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
> >>>>>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
> >>>>>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
> >>>>>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott
> >>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott
> >>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4,
> >>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4,
> >>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4,
> >>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated correctly proving
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> six months
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (even if only for the one case you
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, because P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)" is a simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong because both P(P) and a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no lines of code that are
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulation is incorrect.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SAY.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha3(N,5),
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses the strawman error in an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong or irrelevent you should have no
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> problem explaining why without just saying
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> "strawman".
> >>>>>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the machine language of P
> >>>>>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100%
> >>>>>>>>>>>>>>>>>>>>>>>>>>> specific finite string of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that
> >>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct,
> >>>>>>>>>>>>>>>>>>>>>>>>> More than that.
> >>>>>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct
> >>>>>>>>>>>>>>>>>>>>>>>>> and I prove the
> >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that
> >>>>>>>>>>>>>>>>>>>>>>>>> criteria.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of
> >>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is correct is whether P(P) halts, *by
> >>>>>>>>>>>>>>>>>>>>>>>> definition*.
> >>>>>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am
> >>>>>>>>>>>>>>>>>>>>>>> referring to.
> >>>>>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in
> >>>>>>>>>>>>>>>>>>>>>>> despicable liar mode.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat
> >>>>>>>>>>>>>>>>>>>>>>> that the input to H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace
> >>>>>>>>>>>>>>>>>>>>>>> proves otherwise.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
> >>>>>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86
> >>>>>>>>>>>>>>>>>>>>> machine-code Jackass.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Then you're not talking about the halting problem,
> >>>>>>>>>>>>>>>>>>>> and H is computing something other that the halting
> >>>>>>>>>>>>>>>>>>>> function
> >>>>>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Only for something that is not the halting problem.
> >>>>>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes
> >>>>>>>>>>>>>>>>> the halt status
> >>>>>>>>>>>>>>>>> of the machine language of P that is passed to H on the
> >>>>>>>>>>>>>>>>> stack as a pair
> >>>>>>>>>>>>>>>>> of pointers to the literal string of P?
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't
> >>>>>>>>>>>>>>>> have a halt status because it's not a complete program.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts
> >>>>>>>>>>>>>>> when its correct
> >>>>>>>>>>>>>>> simulation reaches its machine address of [000009f0]
> >>>>>>>>>>>>>>> otherwise it is
> >>>>>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of
> >>>>>>>>>>>>>>> the input to
> >>>>>>>>>>>>>>> H(P,P).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> _P()
> >>>>>>>>>>>>>>> [000009d6](01) 55 push ebp
> >>>>>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
> >>>>>>>>>>>>>>> [000009dc](01) 50 push eax // push P
> >>>>>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
> >>>>>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
> >>>>>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
> >>>>>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
> >>>>>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
> >>>>>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
> >>>>>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
> >>>>>>>>>>>>>>> [000009ef](01) 5d pop ebp
> >>>>>>>>>>>>>>> [000009f0](01) c3 ret // Final state
> >>>>>>>>>>>>>>> Size in bytes:(0027) [000009f0]
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A
> >>>>>>>>>>>>>> correct simulation of this input is done Hb(P,P) which
> >>>>>>>>>>>>>> does in fact reach a final state. Therefore H(P,P)==0 is
> >>>>>>>>>>>>>> wrong.
> >>>>>>>>>>>>> OK then when the literal string of the machine code of H
> >>>>>>>>>>>>> correctly
> >>>>>>>>>>>>> emulates
> >>>>>>>>>>>>
> >>>>>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final
> >>>>>>>>>>>> state and returning 1.
> >>>>>>>>>>> H is at machine address 00000826 every other variation is a
> >>>>>>>>>>> dishonest
> >>>>>>>>>>> dodge away from the actual question.
> >>>>>>>>>>
> >>>>>>>>>> And since the fixed H is programmed to abort
> >>>>>>>>> This is not true and we are not yet discussing that aspect of
> >>>>>>>>> it yet.
> >>>>>>>>
> >>>>>>>> It must be, otherwise you have nothing to decide on. Remember, P
> >>>>>>>> is a *complete* program, which means the H is called must be
> >>>>>>>> fully defined and fixed.
> >>>>>>>>
> >>>>>>> It is ridiculously stupid to say that a halt decider has a fixed
> >>>>>>> behavior.
> >>>>>>
> >>>>>> You have it backwards. It is ridiculously stupid to say that *any*
> >>>>>> computation, *including* a halt decider, does NOT have a fixed
> >>>>>> behavior. That's how a given input always gives the same output.
> >>>>> It has a different behavior for every input, nitwit.
> >>>>> How stupid can you get?
> >>>>
> >>>> Perhaps that was worded incorrectly. The *algorithm* of a
> >>>> computation is fixed, which in turn means its behavior is fixed for
> >>>> a given input.
> >>> Heh that is great. Yeah !!!
> >>> I gave you feedback and we came to mutual agreement.
> >>>>
> >>>>>>>
> >>>>>>> given an input of the function domain it can return the
> >>>>>>> corresponding
> >>>>>>> output. https://en.wikipedia.org/wiki/Computable_function
> >>>>>>
> >>>>>> And for the halting function, its domain is a turing machine M and
> >>>>>> its input w, and its output is: accept if M applied to w halts,
> >>>>>> and reject if M applied to w does not halt. And the question of
> >>>>>> the halting problem is: Is the halting function computable?
> >>>>>>
> >>>>> The domain of H is this finite string:
> >>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
> >>>>
> >>>> Which is not a complete program. So if H's domain is not complete
> >>>> programs, then by definition it is not a halt decider.
> >>> OK then call it a halt determiner.
> >>> None-the-less H(P,P)==0 is correct in such an obvious way that if you
> >>> were unbiased you would have agreed long ago.
> >>>>>
> >>>>> Do you have attention deficit disorder that scrambles your attention
> >>>>> span so that you can't stay focused on H(P,P) ???
> >>>>>>>
> >>>>>>> In any case I am only talking about the simulation of the input to
> >>>>>>> H(P,P). Are you freaking stupid of what?
> >>>>>>>> Otherwise what you're saying is:
> >>>>>>>>
> >>>>>>>> Since H1(P1,P1)==0,
> >>>>>>>> and H2(P2,P2)==0,
> >>>>>>>> and H3(P3,P3)==0,
> >>>>>>>> and H4(P4,P4)==0,
> >>>>>>>> and H5(P5,P5)==0,
> >>>>>>>> ....
> >>>>>>>> and Hn(Pn,Pn) does not halt,
> >>>>>>>> Then for any i, Hi(Pi,Pi) == 0 is correct
> >>>>>>>>
> >>>>>>>> These P's are all separate and distinct computations having
> >>>>>>>> nothing to do with each other.
> >>>>>>>>
> >>>>>>> This is the P that I am referring to knucklehead:
> >>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
> >>>>>>
> >>>>>> So since you aren't specifying H, then you do in fact mean:
> >>>>> I mean that halt decider that P calls.
> >>>>
> >>>> So in other words, since you haven't fixed the algorithm of H:
> >>> The algorithm of H is fixed.
> >>
> >> Alright, so since the fixed algorithm of H aborts,
> >
> > No we won't.
> > With your ADD we have to stay sharply focused on a single point.
> >
> > We are ONLY evaluating whether or not the simulation of the input to
> > H(P,P) is correct. I have been telling you this for many messages now
> > and you keep drifting off topic.
> >
> >
> And given what you have defined P to be, it can't be, because the P you
> have entered isn't actually a computation, since it isn't a complete
> algorithm.
>
> There is NOTHING in your P that defines what happens after the call "H"
> instruction.
>
> Thus, your trace can not be correct.
>
> As I have said before, if H wants to eliminate from the trace the
> showing of what H itself does, the the trace would resume after the call
> to H with the answer that this H returned to P, not a listing of a call
> to P again, which doesn't actually happen (not if H is able to abort its
> "simulation")
>
> Of course, as has been shown, if H does try that, it gets ITSELF stuck
> in an infinte recursion loop and fails to answer and thus fails to be a
> decider.
>
> The transform from a trace of the simumlator to the trace of the code
> that simulator is simulating is NOT a valid transform in this case. If
> you have a proof otherwise, show it. (Or you are just admitting to being
> a Lying Hypocrite since your goal is to show that all true statements
> are provable).
>
This is the crucial remaining question, assuming that everything else is set
up as claimed.
The first seven instructions of the trace are the trace created by the emulator.
It then stops tracing when the code it is emulating calls H. However that
call is itself an emulator. The second seven instructions of the trace are
created by the emulated emulator.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<msednaIIYIv2vhT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 12:37:47 -0500
Date: Sat, 21 May 2022 12:37:46 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<b1db6dde-46c5-4457-9602-7af419bc1bcdn@googlegroups.com>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
<D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>
<d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
<a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com>
<t83iK.2585$vAW9.2416@fx10.iad>
<fc2034d8-96e7-4914-bc46-f5ffabc51ab8n@googlegroups.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <fc2034d8-96e7-4914-bc46-f5ffabc51ab8n@googlegroups.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <msednaIIYIv2vhT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 303
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-jIO4T7cuY6US6ELpnYhoYan51oRFeJCxYYL08OOfnlTQjbnDSyJv7o6tgfE7jSulcyycsimlCiZo3Q4!tDcq2XQHCGRCUXIPsOw+I0uA6OMCVsofQwA11Mn+6RXpJ8sZUh/FDlz5+7Oxti8KA7G7mdf0dSU=
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: 17283
 by: olcott - Sat, 21 May 2022 17:37 UTC

On 5/21/2022 12:24 PM, Malcolm McLean wrote:
> On Saturday, 21 May 2022 at 11:27:41 UTC+1, richar...@gmail.com wrote:
>> On 5/21/22 12:15 AM, olcott wrote:
>>> On 5/20/2022 11:10 PM, Dennis Bush wrote:
>>>> On Saturday, May 21, 2022 at 12:02:33 AM UTC-4, olcott wrote:
>>>>> On 5/20/2022 10:56 PM, Dennis Bush wrote:
>>>>>> On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
>>>>>>> On 5/20/2022 10:37 PM, Dennis Bush wrote:
>>>>>>>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>>>>>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>>>>>>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> six months
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong or irrelevent you should have no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem explaining why without just saying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "strawman".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine language of P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100%
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specific finite string of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> and I prove the
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that
>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is correct is whether P(P) halts, *by
>>>>>>>>>>>>>>>>>>>>>>>>>> definition*.
>>>>>>>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am
>>>>>>>>>>>>>>>>>>>>>>>>> referring to.
>>>>>>>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in
>>>>>>>>>>>>>>>>>>>>>>>>> despicable liar mode.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat
>>>>>>>>>>>>>>>>>>>>>>>>> that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace
>>>>>>>>>>>>>>>>>>>>>>>>> proves otherwise.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86
>>>>>>>>>>>>>>>>>>>>>>> machine-code Jackass.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Then you're not talking about the halting problem,
>>>>>>>>>>>>>>>>>>>>>> and H is computing something other that the halting
>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes
>>>>>>>>>>>>>>>>>>> the halt status
>>>>>>>>>>>>>>>>>>> of the machine language of P that is passed to H on the
>>>>>>>>>>>>>>>>>>> stack as a pair
>>>>>>>>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't
>>>>>>>>>>>>>>>>>> have a halt status because it's not a complete program.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts
>>>>>>>>>>>>>>>>> when its correct
>>>>>>>>>>>>>>>>> simulation reaches its machine address of [000009f0]
>>>>>>>>>>>>>>>>> otherwise it is
>>>>>>>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of
>>>>>>>>>>>>>>>>> the input to
>>>>>>>>>>>>>>>>> H(P,P).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A
>>>>>>>>>>>>>>>> correct simulation of this input is done Hb(P,P) which
>>>>>>>>>>>>>>>> does in fact reach a final state. Therefore H(P,P)==0 is
>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>> OK then when the literal string of the machine code of H
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> emulates
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final
>>>>>>>>>>>>>> state and returning 1.
>>>>>>>>>>>>> H is at machine address 00000826 every other variation is a
>>>>>>>>>>>>> dishonest
>>>>>>>>>>>>> dodge away from the actual question.
>>>>>>>>>>>>
>>>>>>>>>>>> And since the fixed H is programmed to abort
>>>>>>>>>>> This is not true and we are not yet discussing that aspect of
>>>>>>>>>>> it yet.
>>>>>>>>>>
>>>>>>>>>> It must be, otherwise you have nothing to decide on. Remember, P
>>>>>>>>>> is a *complete* program, which means the H is called must be
>>>>>>>>>> fully defined and fixed.
>>>>>>>>>>
>>>>>>>>> It is ridiculously stupid to say that a halt decider has a fixed
>>>>>>>>> behavior.
>>>>>>>>
>>>>>>>> You have it backwards. It is ridiculously stupid to say that *any*
>>>>>>>> computation, *including* a halt decider, does NOT have a fixed
>>>>>>>> behavior. That's how a given input always gives the same output.
>>>>>>> It has a different behavior for every input, nitwit.
>>>>>>> How stupid can you get?
>>>>>>
>>>>>> Perhaps that was worded incorrectly. The *algorithm* of a
>>>>>> computation is fixed, which in turn means its behavior is fixed for
>>>>>> a given input.
>>>>> Heh that is great. Yeah !!!
>>>>> I gave you feedback and we came to mutual agreement.
>>>>>>
>>>>>>>>>
>>>>>>>>> given an input of the function domain it can return the
>>>>>>>>> corresponding
>>>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>
>>>>>>>> And for the halting function, its domain is a turing machine M and
>>>>>>>> its input w, and its output is: accept if M applied to w halts,
>>>>>>>> and reject if M applied to w does not halt. And the question of
>>>>>>>> the halting problem is: Is the halting function computable?
>>>>>>>>
>>>>>>> The domain of H is this finite string:
>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>
>>>>>> Which is not a complete program. So if H's domain is not complete
>>>>>> programs, then by definition it is not a halt decider.
>>>>> OK then call it a halt determiner.
>>>>> None-the-less H(P,P)==0 is correct in such an obvious way that if you
>>>>> were unbiased you would have agreed long ago.
>>>>>>>
>>>>>>> Do you have attention deficit disorder that scrambles your attention
>>>>>>> span so that you can't stay focused on H(P,P) ???
>>>>>>>>>
>>>>>>>>> In any case I am only talking about the simulation of the input to
>>>>>>>>> H(P,P). Are you freaking stupid of what?
>>>>>>>>>> Otherwise what you're saying is:
>>>>>>>>>>
>>>>>>>>>> Since H1(P1,P1)==0,
>>>>>>>>>> and H2(P2,P2)==0,
>>>>>>>>>> and H3(P3,P3)==0,
>>>>>>>>>> and H4(P4,P4)==0,
>>>>>>>>>> and H5(P5,P5)==0,
>>>>>>>>>> ....
>>>>>>>>>> and Hn(Pn,Pn) does not halt,
>>>>>>>>>> Then for any i, Hi(Pi,Pi) == 0 is correct
>>>>>>>>>>
>>>>>>>>>> These P's are all separate and distinct computations having
>>>>>>>>>> nothing to do with each other.
>>>>>>>>>>
>>>>>>>>> This is the P that I am referring to knucklehead:
>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>
>>>>>>>> So since you aren't specifying H, then you do in fact mean:
>>>>>>> I mean that halt decider that P calls.
>>>>>>
>>>>>> So in other words, since you haven't fixed the algorithm of H:
>>>>> The algorithm of H is fixed.
>>>>
>>>> Alright, so since the fixed algorithm of H aborts,
>>>
>>> No we won't.
>>> With your ADD we have to stay sharply focused on a single point.
>>>
>>> We are ONLY evaluating whether or not the simulation of the input to
>>> H(P,P) is correct. I have been telling you this for many messages now
>>> and you keep drifting off topic.
>>>
>>>
>> And given what you have defined P to be, it can't be, because the P you
>> have entered isn't actually a computation, since it isn't a complete
>> algorithm.
>>
>> There is NOTHING in your P that defines what happens after the call "H"
>> instruction.
>>
>> Thus, your trace can not be correct.
>>
>> As I have said before, if H wants to eliminate from the trace the
>> showing of what H itself does, the the trace would resume after the call
>> to H with the answer that this H returned to P, not a listing of a call
>> to P again, which doesn't actually happen (not if H is able to abort its
>> "simulation")
>>
>> Of course, as has been shown, if H does try that, it gets ITSELF stuck
>> in an infinte recursion loop and fails to answer and thus fails to be a
>> decider.
>>
>> The transform from a trace of the simumlator to the trace of the code
>> that simulator is simulating is NOT a valid transform in this case. If
>> you have a proof otherwise, show it. (Or you are just admitting to being
>> a Lying Hypocrite since your goal is to show that all true statements
>> are provable).
>>
> This is the crucial remaining question, assuming that everything else is set
> up as claimed.
> The first seven instructions of the trace are the trace created by the emulator.
> It then stops tracing when the code it is emulating calls H.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Dennis has ADD ? ]

<hIaiK.50$CBlb.26@fx42.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx42.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Dennis has ADD ? ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<j7GdncfyY7Dx3hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<8b698f68-c947-4c7d-8dea-8425e47f6addn@googlegroups.com>
<k96dneY2F7_q2hX_nZ2dnUU7_8zNnZ2d@giganews.com>
<e5d5c475-b46b-4706-b612-e2d95d1a27edn@googlegroups.com>
<VamdnY9Yf5M61hX_nZ2dnUU7_81g4p2d@giganews.com>
<9fb3aafb-f767-40b3-acc7-b31e3ac7edaan@googlegroups.com>
<DP-dnVGIpcGszxX_nZ2dnUU7_81g4p2d@giganews.com>
<80adcee7-e35f-4bdf-b1a2-518c9930cfc3n@googlegroups.com>
<oLednYpFCuBTxRX_nZ2dnUU7_8zNnZ2d@giganews.com>
<3244af54-a6ea-4310-b166-16d7887faa0cn@googlegroups.com>
<Ws2dnYtFk9AlwhX_nZ2dnUU7_8zNnZ2d@giganews.com>
<78a05997-d753-41c6-918b-820cd0d50b0fn@googlegroups.com>
<D_GdnUyF1ZnP-RX_nZ2dnUU7_8zNnZ2d@giganews.com>
<d08281ec-e682-4e4d-aac1-831fc270f6d4n@googlegroups.com>
<a4Kdndy0q_zG-hX_nZ2dnUU7_83NnZ2d@giganews.com>
<t83iK.2585$vAW9.2416@fx10.iad>
<fc2034d8-96e7-4914-bc46-f5ffabc51ab8n@googlegroups.com>
<msednaIIYIv2vhT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <msednaIIYIv2vhT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 318
Message-ID: <hIaiK.50$CBlb.26@fx42.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: Sat, 21 May 2022 15:03:41 -0400
X-Received-Bytes: 17479
 by: Richard Damon - Sat, 21 May 2022 19:03 UTC

On 5/21/22 1:37 PM, olcott wrote:
> On 5/21/2022 12:24 PM, Malcolm McLean wrote:
>> On Saturday, 21 May 2022 at 11:27:41 UTC+1, richar...@gmail.com wrote:
>>> On 5/21/22 12:15 AM, olcott wrote:
>>>> On 5/20/2022 11:10 PM, Dennis Bush wrote:
>>>>> On Saturday, May 21, 2022 at 12:02:33 AM UTC-4, olcott wrote:
>>>>>> On 5/20/2022 10:56 PM, Dennis Bush wrote:
>>>>>>> On Friday, May 20, 2022 at 11:42:55 PM UTC-4, olcott wrote:
>>>>>>>> On 5/20/2022 10:37 PM, Dennis Bush wrote:
>>>>>>>>> On Friday, May 20, 2022 at 11:13:25 PM UTC-4, olcott wrote:
>>>>>>>>>> On 5/20/2022 10:06 PM, Dennis Bush wrote:
>>>>>>>>>>> On Friday, May 20, 2022 at 10:45:12 PM UTC-4, olcott wrote:
>>>>>>>>>>>> On 5/20/2022 9:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>> On Friday, May 20, 2022 at 10:17:18 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>> On 5/20/2022 9:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:59:27 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>> On 5/20/2022 8:51 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 9:42:11 PM UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>> On 5/20/2022 8:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:56:09 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>> On 5/20/2022 7:32 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 8:15:31 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 7:09 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:37:15 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:31 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:25:15 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:21 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:13:37 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 6:11 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 7:02:24 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:53 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:51:42 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:44 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Friday, May 20, 2022 at 6:33:29 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> writes:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have known that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is simulated correctly proving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0 is correct for the whole
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> six months
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If H is intended to be a halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (even if only for the one case you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim to care about) then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong, because P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If a "correct simulation of the input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)" is a simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function call P(P), then H(P,P) == 0 is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong because both P(P) and a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of P(P) halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So in other words even though there are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no lines of code that are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated incorrectly you still claim
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulation is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> THAT IS WHAT A DAMNED LYING BASTARD WOULD
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> SAY.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if we look at the execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha3(N,5),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet another God damned lying bastard that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> uses the strawman error in an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> attempt to get away with deception.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So if you believe that Ha3(N,5)==0 is either
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrong or irrelevent you should have no
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> problem explaining why without just saying
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "strawman".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am talking about the correct simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the machine language of P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> being correctly emulated by another 100%
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specific finite string of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine language named H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And by the criteria you use to show that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> More than that.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I prove that the criteria that I use is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and I prove the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)==0 is correct on the basis of that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The *only* criteria for whether the result of
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is correct is whether P(P) halts, *by
>>>>>>>>>>>>>>>>>>>>>>>>>>> definition*.
>>>>>>>>>>>>>>>>>>>>>>>>>> Not for the specific machine language that I am
>>>>>>>>>>>>>>>>>>>>>>>>>> referring to.
>>>>>>>>>>>>>>>>>>>>>>>>>> So OK you prove that you intend to stay in
>>>>>>>>>>>>>>>>>>>>>>>>>> despicable liar mode.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You proclaim by lying bastard dictatorial fiat
>>>>>>>>>>>>>>>>>>>>>>>>>> that the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>> halts even though its correct execution trace
>>>>>>>>>>>>>>>>>>>>>>>>>> proves otherwise.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The input to H(P,P) represents P(P) by definition.
>>>>>>>>>>>>>>>>>>>>>>>> Not when we are talking about C functions and x86
>>>>>>>>>>>>>>>>>>>>>>>> machine-code Jackass.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Then you're not talking about the halting problem,
>>>>>>>>>>>>>>>>>>>>>>> and H is computing something other that the halting
>>>>>>>>>>>>>>>>>>>>>>> function
>>>>>>>>>>>>>>>>>>>>>> None-the-less H(P,P)==0 is proven to be correct.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Only for something that is not the halting problem.
>>>>>>>>>>>>>>>>>>>> So you agree that H(P,P)==0 is correct when H computes
>>>>>>>>>>>>>>>>>>>> the halt status
>>>>>>>>>>>>>>>>>>>> of the machine language of P that is passed to H on the
>>>>>>>>>>>>>>>>>>>> stack as a pair
>>>>>>>>>>>>>>>>>>>> of pointers to the literal string of P?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If you're referring to *just* the function P, it doesn't
>>>>>>>>>>>>>>>>>>> have a halt status because it's not a complete program.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When we stipulate that the input to H(P,P) only halts
>>>>>>>>>>>>>>>>>> when its correct
>>>>>>>>>>>>>>>>>> simulation reaches its machine address of [000009f0]
>>>>>>>>>>>>>>>>>> otherwise it is
>>>>>>>>>>>>>>>>>> non-halting then H(P,P)==0 is the correct halt status of
>>>>>>>>>>>>>>>>>> the input to
>>>>>>>>>>>>>>>>>> H(P,P).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _P()
>>>>>>>>>>>>>>>>>> [000009d6](01) 55 push ebp
>>>>>>>>>>>>>>>>>> [000009d7](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>> [000009d9](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [000009dc](01) 50 push eax // push P
>>>>>>>>>>>>>>>>>> [000009dd](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [000009e0](01) 51 push ecx // push P
>>>>>>>>>>>>>>>>>> [000009e1](05) e840feffff call 00000826 // call H
>>>>>>>>>>>>>>>>>> [000009e6](03) 83c408 add esp,+08
>>>>>>>>>>>>>>>>>> [000009e9](02) 85c0 test eax,eax
>>>>>>>>>>>>>>>>>> [000009eb](02) 7402 jz 000009ef
>>>>>>>>>>>>>>>>>> [000009ed](02) ebfe jmp 000009ed
>>>>>>>>>>>>>>>>>> [000009ef](01) 5d pop ebp
>>>>>>>>>>>>>>>>>> [000009f0](01) c3 ret // Final state
>>>>>>>>>>>>>>>>>> Size in bytes:(0027) [000009f0]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But H(P,P) does *not* perform a correct of its input. A
>>>>>>>>>>>>>>>>> correct simulation of this input is done Hb(P,P) which
>>>>>>>>>>>>>>>>> does in fact reach a final state. Therefore H(P,P)==0 is
>>>>>>>>>>>>>>>>> wrong.
>>>>>>>>>>>>>>>> OK then when the literal string of the machine code of H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> emulates
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Which is doesn't as demonstrated by Hb(P,P) reaching a final
>>>>>>>>>>>>>>> state and returning 1.
>>>>>>>>>>>>>> H is at machine address 00000826 every other variation is a
>>>>>>>>>>>>>> dishonest
>>>>>>>>>>>>>> dodge away from the actual question.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And since the fixed H is programmed to abort
>>>>>>>>>>>> This is not true and we are not yet discussing that aspect of
>>>>>>>>>>>> it yet.
>>>>>>>>>>>
>>>>>>>>>>> It must be, otherwise you have nothing to decide on. Remember, P
>>>>>>>>>>> is a *complete* program, which means the H is called must be
>>>>>>>>>>> fully defined and fixed.
>>>>>>>>>>>
>>>>>>>>>> It is ridiculously stupid to say that a halt decider has a fixed
>>>>>>>>>> behavior.
>>>>>>>>>
>>>>>>>>> You have it backwards. It is ridiculously stupid to say that *any*
>>>>>>>>> computation, *including* a halt decider, does NOT have a fixed
>>>>>>>>> behavior. That's how a given input always gives the same output.
>>>>>>>> It has a different behavior for every input, nitwit.
>>>>>>>> How stupid can you get?
>>>>>>>
>>>>>>> Perhaps that was worded incorrectly. The *algorithm* of a
>>>>>>> computation is fixed, which in turn means its behavior is fixed for
>>>>>>> a given input.
>>>>>> Heh that is great. Yeah !!!
>>>>>> I gave you feedback and we came to mutual agreement.
>>>>>>>
>>>>>>>>>>
>>>>>>>>>> given an input of the function domain it can return the
>>>>>>>>>> corresponding
>>>>>>>>>> output. https://en.wikipedia.org/wiki/Computable_function
>>>>>>>>>
>>>>>>>>> And for the halting function, its domain is a turing machine M and
>>>>>>>>> its input w, and its output is: accept if M applied to w halts,
>>>>>>>>> and reject if M applied to w does not halt. And the question of
>>>>>>>>> the halting problem is: Is the halting function computable?
>>>>>>>>>
>>>>>>>> The domain of H is this finite string:
>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>
>>>>>>> Which is not a complete program. So if H's domain is not complete
>>>>>>> programs, then by definition it is not a halt decider.
>>>>>> OK then call it a halt determiner.
>>>>>> None-the-less H(P,P)==0 is correct in such an obvious way that if you
>>>>>> were unbiased you would have agreed long ago.
>>>>>>>>
>>>>>>>> Do you have attention deficit disorder that scrambles your
>>>>>>>> attention
>>>>>>>> span so that you can't stay focused on H(P,P) ???
>>>>>>>>>>
>>>>>>>>>> In any case I am only talking about the simulation of the
>>>>>>>>>> input to
>>>>>>>>>> H(P,P). Are you freaking stupid of what?
>>>>>>>>>>> Otherwise what you're saying is:
>>>>>>>>>>>
>>>>>>>>>>> Since H1(P1,P1)==0,
>>>>>>>>>>> and H2(P2,P2)==0,
>>>>>>>>>>> and H3(P3,P3)==0,
>>>>>>>>>>> and H4(P4,P4)==0,
>>>>>>>>>>> and H5(P5,P5)==0,
>>>>>>>>>>> ....
>>>>>>>>>>> and Hn(Pn,Pn) does not halt,
>>>>>>>>>>> Then for any i, Hi(Pi,Pi) == 0 is correct
>>>>>>>>>>>
>>>>>>>>>>> These P's are all separate and distinct computations having
>>>>>>>>>>> nothing to do with each other.
>>>>>>>>>>>
>>>>>>>>>> This is the P that I am referring to knucklehead:
>>>>>>>>>> 558bec8b4508508b4d0851e840feffff83c40885c07402ebfe5dc3
>>>>>>>>>
>>>>>>>>> So since you aren't specifying H, then you do in fact mean:
>>>>>>>> I mean that halt decider that P calls.
>>>>>>>
>>>>>>> So in other words, since you haven't fixed the algorithm of H:
>>>>>> The algorithm of H is fixed.
>>>>>
>>>>> Alright, so since the fixed algorithm of H aborts,
>>>>
>>>> No we won't.
>>>> With your ADD we have to stay sharply focused on a single point.
>>>>
>>>> We are ONLY evaluating whether or not the simulation of the input to
>>>> H(P,P) is correct. I have been telling you this for many messages now
>>>> and you keep drifting off topic.
>>>>
>>>>
>>> And given what you have defined P to be, it can't be, because the P you
>>> have entered isn't actually a computation, since it isn't a complete
>>> algorithm.
>>>
>>> There is NOTHING in your P that defines what happens after the call "H"
>>> instruction.
>>>
>>> Thus, your trace can not be correct.
>>>
>>> As I have said before, if H wants to eliminate from the trace the
>>> showing of what H itself does, the the trace would resume after the call
>>> to H with the answer that this H returned to P, not a listing of a call
>>> to P again, which doesn't actually happen (not if H is able to abort its
>>> "simulation")
>>>
>>> Of course, as has been shown, if H does try that, it gets ITSELF stuck
>>> in an infinte recursion loop and fails to answer and thus fails to be a
>>> decider.
>>>
>>> The transform from a trace of the simumlator to the trace of the code
>>> that simulator is simulating is NOT a valid transform in this case. If
>>> you have a proof otherwise, show it. (Or you are just admitting to being
>>> a Lying Hypocrite since your goal is to show that all true statements
>>> are provable).
>>>
>> This is the crucial remaining question, assuming that everything else
>> is set
>> up as claimed.
>> The first seven instructions of the trace are the trace created by the
>> emulator.
>> It then stops tracing when the code it is emulating calls H.
>
>
> This is false. The emulator always outputs the complete execution trace
> of all user code and does not trace nay operating system code. Also the
> emulator does not create any instructions it merely outputs the
> execution trace of the x86 code that it is emulating.
>
>> However that
>> call is itself an emulator. The second seven instructions of the trace
>> are
>> created by the emulated emulator.
>>
>
> Not created.


Click here to read the complete article
Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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: Sat, 21 May 2022 14:38:18 -0500
Date: Sat, 21 May 2022 14:38:17 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<EuidnURwxcY6vhj_nZ2dnUU7_8zNnZ2d@giganews.com> <87o7zu8hk8.fsf@bsb.me.uk>
<04qdnQ2ArKr2Bhj_nZ2dnUU7_83NnZ2d@giganews.com> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <87bkvr3kqn.fsf@bsb.me.uk>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-yOdw4ZmMi1pR1Uz6emMKAEyshB0j1WsDrDDSWgmtCkdNaP8Clet3zbgabNYoU0buXg/FukxqtJAsYoS!gE/7MeNwWaxPQev2P1FMhtpbVoJDa0McSpmH7+MHe5ygOUvgfJTQIeLE+wsu8qdahAksQNqOA6A=
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: 3862
 by: olcott - Sat, 21 May 2022 19:38 UTC

On 5/20/2022 5:25 PM, Ben wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> You have known that the input to H(P,P) is simulated correctly proving
>> that H(P,P)==0 is correct for the whole six months
>
> If H is intended to be a halt decider (even if only for the one case you
> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>

When we correctly reverse-engineer what the execution trace of the input
to H(P,P) would be for one emulation and one nested emulation we can see
that the correctly emulated input to H(P,P) would never reach its final
state at machine address [0000136c].

This conclusively proves the the C function H does correctly decide the
halt status of its machine language input that is passed to it on the
stack as parameters.

Also because you know full well that P(P) is an entirely different
computation you know full well that referring to the behavior of P(P) is
the dishonest attempt at trying to get away with the strawman error.

_P()
[00001352](01) 55 push ebp
[00001353](02) 8bec mov ebp,esp
[00001355](03) 8b4508 mov eax,[ebp+08]
[00001358](01) 50 push eax // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[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]

--
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: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<r%fiK.28447$J0r9.3351@fx11.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx11.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<EuidnURwxcY6vhj_nZ2dnUU7_8zNnZ2d@giganews.com> <87o7zu8hk8.fsf@bsb.me.uk>
<04qdnQ2ArKr2Bhj_nZ2dnUU7_83NnZ2d@giganews.com> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 56
Message-ID: <r%fiK.28447$J0r9.3351@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: Sat, 21 May 2022 21:05:27 -0400
X-Received-Bytes: 3960
 by: Richard Damon - Sun, 22 May 2022 01:05 UTC

On 5/21/22 3:38 PM, olcott wrote:
> On 5/20/2022 5:25 PM, Ben wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> You have known that the input to H(P,P) is simulated correctly proving
>>> that H(P,P)==0 is correct for the whole six months
>>
>> If H is intended to be a halt decider (even if only for the one case you
>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>
>
> When we correctly reverse-engineer what the execution trace of the input
> to H(P,P) would be for one emulation and one nested emulation we can see
> that the correctly emulated input to H(P,P) would never reach its final
> state at machine address [0000136c].

A nonsense trace, as it is mixing the execution path of two independent
execution units.

>
> This conclusively proves the the C function H does correctly decide the
> halt status of its machine language input that is passed to it on the
> stack as parameters.

Nope.

>
> Also because you know full well that P(P) is an entirely different
> computation you know full well that referring to the behavior of P(P) is
> the dishonest attempt at trying to get away with the strawman error.

Then H isn't a Halting Decider. FAIL.

>
> _P()
> [00001352](01)  55              push ebp
> [00001353](02)  8bec            mov ebp,esp
> [00001355](03)  8b4508          mov eax,[ebp+08]
> [00001358](01)  50              push eax      // push P
> [00001359](03)  8b4d08          mov ecx,[ebp+08]
> [0000135c](01)  51              push ecx      // push P
> [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]
>

Incomplete program. Might core dump at the call 000011a2 command,
because no code has been loaded there.

FAIL.

Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 20:23:21 -0500
Date: Sat, 21 May 2022 20:23:19 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<EuidnURwxcY6vhj_nZ2dnUU7_8zNnZ2d@giganews.com> <87o7zu8hk8.fsf@bsb.me.uk>
<04qdnQ2ArKr2Bhj_nZ2dnUU7_83NnZ2d@giganews.com> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <r%fiK.28447$J0r9.3351@fx11.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 54
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ZfassDiP9MLQwBgFMhNwh7Uh7O0CO6RW+lEJL/3NdzW/+AFE4CAfcxU8Ybc9zdVow6+tZSlvHuZAddf!IUMVaX/GhVrXgS5szgmbA+mn/SQkvtw2Y4ZvqVbZumZOKZ1smitvjQHAq/fxZpPNQdFfbvm8cmM=
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: 4296
 by: olcott - Sun, 22 May 2022 01:23 UTC

On 5/21/2022 8:05 PM, Richard Damon wrote:
> On 5/21/22 3:38 PM, olcott wrote:
>> On 5/20/2022 5:25 PM, Ben wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> You have known that the input to H(P,P) is simulated correctly proving
>>>> that H(P,P)==0 is correct for the whole six months
>>>
>>> If H is intended to be a halt decider (even if only for the one case you
>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>
>>
>> When we correctly reverse-engineer what the execution trace of the
>> input to H(P,P) would be for one emulation and one nested emulation we
>> can see that the correctly emulated input to H(P,P) would never reach
>> its final state at machine address [0000136c].
>
> A nonsense trace, as it is mixing the execution path of two independent
> execution units.
>
In other words you acknowledge that you are technically incompetent to
provide the execution trace of one simulation and one nested simulation
of the input to H(P,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 // push P
[00001359](03) 8b4d08 mov ecx,[ebp+08]
[0000135c](01) 51 push ecx // push P
[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]

You know that the emulation of the input by H(P,P) executes the first
seven instruction of P, yet when P calls H(P,P) (the same call as
before) you haven't the slightest clue about what the behavior of P
might possibly be?

For all you know P might play a game of tic-tac-toe when it is emulated
in exactly the same way a second time.

--
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: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<s5hiK.45$cq8.28@fx03.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx03.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<EuidnURwxcY6vhj_nZ2dnUU7_8zNnZ2d@giganews.com> <87o7zu8hk8.fsf@bsb.me.uk>
<04qdnQ2ArKr2Bhj_nZ2dnUU7_83NnZ2d@giganews.com> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 142
Message-ID: <s5hiK.45$cq8.28@fx03.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: Sat, 21 May 2022 22:20:07 -0400
X-Received-Bytes: 7739
 by: Richard Damon - Sun, 22 May 2022 02:20 UTC

On 5/21/22 9:23 PM, olcott wrote:
> On 5/21/2022 8:05 PM, Richard Damon wrote:
>> On 5/21/22 3:38 PM, olcott wrote:
>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> You have known that the input to H(P,P) is simulated correctly proving
>>>>> that H(P,P)==0 is correct for the whole six months
>>>>
>>>> If H is intended to be a halt decider (even if only for the one case
>>>> you
>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>
>>>
>>> When we correctly reverse-engineer what the execution trace of the
>>> input to H(P,P) would be for one emulation and one nested emulation
>>> we can see that the correctly emulated input to H(P,P) would never
>>> reach its final state at machine address [0000136c].
>>
>> A nonsense trace, as it is mixing the execution path of two
>> independent execution units.
>>
> In other words you acknowledge that you are technically incompetent to
> provide the execution trace of one simulation and one nested simulation
> of the input to H(P,P).

No, I am saying that you are asking for the equivalent of a of a square
circle.

NO corrext execution trace mixes the trace of different execution units,
as the two levels of simulation are.

YOU are showing your technical incompetence.

I DID show a trace the closes that can be done:

....[00001352][0021233e][00212342] 55 push ebp // enter P
....[00001353][0021233e][00212342] 8bec mov ebp,esp
....[00001355][0021233e][00212342] 8b4508 mov eax,[ebp+08]
....[00001358][0021233a][00001352] 50 push eax // push P
....[00001359][0021233a][00001352] 8b4d08 mov ecx,[ebp+08]
....[0000135c][00212336][00001352] 51 push ecx // push P
....[0000135d][00212332][00001362] e840feffff call 000011a2

Simulation of:
....[00001352][?????33e][00212342] 55 push ebp // enter P
Abort decision: No
Simulation of:
....[00001353][?????33e][00212342] 8bec mov ebp,esp
Abort decision: No
Simulation of:
....[00001355][?????33e][00212342] 8b4508 mov eax,[ebp+08]
Abort decision: No
Simulation of:
....[00001358][?????33a][00001352] 50 push eax // push P
Abort decision: No
Simulation of:
....[00001359][?????33a][00001352] 8b4d08 mov ecx,[ebp+08]
Abort decision: No
Simulation of:
....[0000135c][?????336][00001352] 51 push ecx // push P
Abort decision: No
Simulation of:
....[0000135d][?????332][00001362] e840feffff call 000011a2
Abort decision: No

(Side note, I am copying the base trace from your traces, since I am
doing this by hand, why did the SP change after the mov eax,[ebp+08]
instruction, or are you being inconsistant and showing the PC before the
instruction, but the stack after? Or are you just manually making this
up and making mistakes?)

Which makes what is happening explicit, and shows that your 'infinite
recursion' test doesn't work here, as we KNOW that if H answers, at some
point one of the Abort Decisions will become yes, and break the
otherwise apparent infinite recursion. (The rule you are thinking of
using requires no conditionals in the 'loop')

So, your arguement is proved to be invalid.

>
> _P()
> [00001352](01)  55              push ebp
> [00001353](02)  8bec            mov ebp,esp
> [00001355](03)  8b4508          mov eax,[ebp+08]
> [00001358](01)  50              push eax      // push P
> [00001359](03)  8b4d08          mov ecx,[ebp+08]
> [0000135c](01)  51              push ecx      // push P
> [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]
>
> You know that the emulation of the input by H(P,P) executes the first
> seven instruction of P, yet when P calls H(P,P) (the same call as
> before) you haven't the slightest clue about what the behavior of P
> might possibly be?

Since, you just traced to P calling H, and you haven't actually defined
what H does, of course I can't know what it does.

You say it simulates it input, and that is EXACTLY what my first answer
said, H simulates its input and decides that it is non-halting and
returns a 0, so P(P) will Halt.

We know that this H(P,P) returns 0, as you have stipulated that it does
so, since the outer H does this, and H is stipulated to be a
computation, so all H(P,P)'s must behave the same.

>
> For all you know P might play a game of tic-tac-toe when it is emulated
> in exactly the same way a second time.
>

You are just proving your incompetence. because you are saying stupid
things. Maybe your problem is you can't read actual English.

I NEVER said I didn't know what the code in the function P does, just
that I can't provide a CORRECT TRACE of what all of the PROGRAM P does,
since I don't have the code for H.

Also, a correct trace shows the execution path of a single exection
unit, so the P being simulated by the original decider, and the
simulated machine done by the H being called, don't just combine,
because they aren't of the same execution unit. (That is why you gave
new stack address)

As I previously posted, you can abstract out the trace, either with the
generic description of what we know H does as a function, or the above
trace that shows it simulating the individual instructions, and making
decisions, and thus the rule it is using doesn't work.

FAIL.

You are proven to be incompenent,

Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 21:28:38 -0500
Date: Sat, 21 May 2022 21:28:36 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc> <87o7zu8hk8.fsf@bsb.me.uk>
<04qdnQ2ArKr2Bhj_nZ2dnUU7_83NnZ2d@giganews.com> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <s5hiK.45$cq8.28@fx03.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 48
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-q6b2THNBYIPIK9T/FIgYtGbk4olytM7fhTGj8CdzxzI6l8Ml+ydvenfhC9l50pzV0JYq/TbSnqqKD/o!5Z4TO1rU9rOOSPX5DpxjGIjKYrYWP3XlpSydUHmEo2CLAhd4+2N8oRbDvOkVZw+U+Wy8Q2ooQXk=
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: 3993
 by: olcott - Sun, 22 May 2022 02:28 UTC

On 5/21/2022 9:20 PM, Richard Damon wrote:
>
> On 5/21/22 9:23 PM, olcott wrote:
>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>> On 5/21/22 3:38 PM, olcott wrote:
>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> You have known that the input to H(P,P) is simulated correctly
>>>>>> proving
>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>
>>>>> If H is intended to be a halt decider (even if only for the one
>>>>> case you
>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>
>>>>
>>>> When we correctly reverse-engineer what the execution trace of the
>>>> input to H(P,P) would be for one emulation and one nested emulation
>>>> we can see that the correctly emulated input to H(P,P) would never
>>>> reach its final state at machine address [0000136c].
>>>
>>> A nonsense trace, as it is mixing the execution path of two
>>> independent execution units.
>>>
>> In other words you acknowledge that you are technically incompetent to
>> provide the execution trace of one simulation and one nested
>> simulation of the input to H(P,P).
>
> No, I am saying that you are asking for the equivalent of a of a square
> circle.

So an execution trace of the input to H(P,P) is easy to show when H
simulates its input, yet another execution trace of the input to H(P,P)
that was invoked by P is "like a square circle" can't possibly exist?

Everyone here (including you) know that is a ridiculously stupid thing
to say. What is you motive for saying these ridiculously stupid things ?
Are you tying to announce to the world that you are a total numbskull?

--
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: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<MlhiK.9438$kaDc.6185@fx46.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx46.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<04qdnQ2ArKr2Bhj_nZ2dnUU7_83NnZ2d@giganews.com> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 54
Message-ID: <MlhiK.9438$kaDc.6185@fx46.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: Sat, 21 May 2022 22:37:32 -0400
X-Received-Bytes: 4021
 by: Richard Damon - Sun, 22 May 2022 02:37 UTC

On 5/21/22 10:28 PM, olcott wrote:
> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>
>> On 5/21/22 9:23 PM, olcott wrote:
>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> You have known that the input to H(P,P) is simulated correctly
>>>>>>> proving
>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>
>>>>>> If H is intended to be a halt decider (even if only for the one
>>>>>> case you
>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>
>>>>>
>>>>> When we correctly reverse-engineer what the execution trace of the
>>>>> input to H(P,P) would be for one emulation and one nested emulation
>>>>> we can see that the correctly emulated input to H(P,P) would never
>>>>> reach its final state at machine address [0000136c].
>>>>
>>>> A nonsense trace, as it is mixing the execution path of two
>>>> independent execution units.
>>>>
>>> In other words you acknowledge that you are technically incompetent
>>> to provide the execution trace of one simulation and one nested
>>> simulation of the input to H(P,P).
>>
>> No, I am saying that you are asking for the equivalent of a of a
>> square circle.
>
>
> So an execution trace of the input to H(P,P) is easy to show when H
> simulates its input, yet another execution trace of the input to H(P,P)
> that was invoked by P is "like a square circle" can't possibly exist?

The problem is that your second trace is NOT a piece of the first.

The fact you don't understand that says you just don't know how
computers or programs actually work.

>
> Everyone here (including you) know that is a ridiculously stupid thing
> to say. What is you motive for saying these ridiculously stupid things ?
> Are you tying to announce to the world that you are a total numbskull?
>

Yes, ON YOUR PART. It is stupid to suggest that it is correct to mix the
execution trace of different execution contexts as if they were a single
context.

When you understand that, you might be able to see your error.

Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<h6OdnUMaNIa5ORT_nZ2dnUU7_83NnZ2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 21:47:00 -0500
Date: Sat, 21 May 2022 21:46:58 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
<MlhiK.9438$kaDc.6185@fx46.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <MlhiK.9438$kaDc.6185@fx46.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <h6OdnUMaNIa5ORT_nZ2dnUU7_83NnZ2d@giganews.com>
Lines: 68
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-aoxsvbyZ2FfbIkHC3rxxI54a4CIQXNR4EanzNIis5bO5idz53+rDqapbsHwbOan1eHaN3PsDgK6xd/r!SmrpxLvyZAUvOE8/E+gY5qwH76iH3oshYjZAIACeuSmkG8N5OwBmTxNWeDZwWD8eO47Qp+nT80U=
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: 4757
 by: olcott - Sun, 22 May 2022 02:46 UTC

On 5/21/2022 9:37 PM, Richard Damon wrote:
> On 5/21/22 10:28 PM, olcott wrote:
>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>
>>> On 5/21/22 9:23 PM, olcott wrote:
>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> You have known that the input to H(P,P) is simulated correctly
>>>>>>>> proving
>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>
>>>>>>> If H is intended to be a halt decider (even if only for the one
>>>>>>> case you
>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>
>>>>>>
>>>>>> When we correctly reverse-engineer what the execution trace of the
>>>>>> input to H(P,P) would be for one emulation and one nested
>>>>>> emulation we can see that the correctly emulated input to H(P,P)
>>>>>> would never reach its final state at machine address [0000136c].
>>>>>
>>>>> A nonsense trace, as it is mixing the execution path of two
>>>>> independent execution units.
>>>>>
>>>> In other words you acknowledge that you are technically incompetent
>>>> to provide the execution trace of one simulation and one nested
>>>> simulation of the input to H(P,P).
>>>
>>> No, I am saying that you are asking for the equivalent of a of a
>>> square circle.
>>
>>
>> So an execution trace of the input to H(P,P) is easy to show when H
>> simulates its input, yet another execution trace of the input to
>> H(P,P) that was invoked by P is "like a square circle" can't possibly
>> exist?
>
> The problem is that your second trace is NOT a piece of the first.
>
> The fact you don't understand that says you just don't know how
> computers or programs actually work.
>

When a UTM simulates a TM description that calls a UTM that simulates a
TM description all of this is simply data on the first UTM's tape.

>>
>> Everyone here (including you) know that is a ridiculously stupid thing
>> to say. What is you motive for saying these ridiculously stupid things ?
>> Are you tying to announce to the world that you are a total numbskull?
>>
>
> Yes, ON YOUR PART. It is stupid to suggest that it is correct to mix the
> execution trace of different execution contexts as if they were a single
> context.
>
> When you understand that, you might be able to see your error.

--
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: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 21:48:40 -0500
Date: Sat, 21 May 2022 21:48:39 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc> <87a6bd91n1.fsf@bsb.me.uk>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
<MlhiK.9438$kaDc.6185@fx46.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <MlhiK.9438$kaDc.6185@fx46.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 70
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ewk6gBO3RWmfE/bsCU1lPizHDHh3qTnU4mnpfrh7jLj+H/7iM7IK4Z+2LvTaTQujwtNkPfT7XH951w0!aXcP/sACud6bGTMuKptHlc07MbTu39ytmR0Pi1IxYaQRoh9K3/n+GcssGg0qmKYIFfjA1D3LlCk=
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: 4808
 by: olcott - Sun, 22 May 2022 02:48 UTC

On 5/21/2022 9:37 PM, Richard Damon wrote:
> On 5/21/22 10:28 PM, olcott wrote:
>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>
>>> On 5/21/22 9:23 PM, olcott wrote:
>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> You have known that the input to H(P,P) is simulated correctly
>>>>>>>> proving
>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>
>>>>>>> If H is intended to be a halt decider (even if only for the one
>>>>>>> case you
>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>
>>>>>>
>>>>>> When we correctly reverse-engineer what the execution trace of the
>>>>>> input to H(P,P) would be for one emulation and one nested
>>>>>> emulation we can see that the correctly emulated input to H(P,P)
>>>>>> would never reach its final state at machine address [0000136c].
>>>>>
>>>>> A nonsense trace, as it is mixing the execution path of two
>>>>> independent execution units.
>>>>>
>>>> In other words you acknowledge that you are technically incompetent
>>>> to provide the execution trace of one simulation and one nested
>>>> simulation of the input to H(P,P).
>>>
>>> No, I am saying that you are asking for the equivalent of a of a
>>> square circle.
>>
>>
>> So an execution trace of the input to H(P,P) is easy to show when H
>> simulates its input, yet another execution trace of the input to
>> H(P,P) that was invoked by P is "like a square circle" can't possibly
>> exist?
>
> The problem is that your second trace is NOT a piece of the first.
>
> The fact you don't understand that says you just don't know how
> computers or programs actually work.
>

When a UTM simulates a TM description that calls a UTM that simulates a
TM description all of this is simply data on the first UTM's tape and
the only actual executable is the first UTM.

>>
>> Everyone here (including you) know that is a ridiculously stupid thing
>> to say. What is you motive for saying these ridiculously stupid things ?
>> Are you tying to announce to the world that you are a total numbskull?
>>
>
> Yes, ON YOUR PART. It is stupid to suggest that it is correct to mix the
> execution trace of different execution contexts as if they were a single
> context.
>
> When you understand that, you might be able to see your error.

--
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: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<K4iiK.20028$zgr9.11815@fx13.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!news-out.netnews.com!news.alt.net!fdc2.netnews.com!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx13.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.9.0
Subject: Re: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<RuGdnaqBNspG-xv_nZ2dnUU7_8zNnZ2d@giganews.com> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
<MlhiK.9438$kaDc.6185@fx46.iad>
<h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 83
Message-ID: <K4iiK.20028$zgr9.11815@fx13.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 21 May 2022 23:27:36 -0400
X-Received-Bytes: 5217
 by: Richard Damon - Sun, 22 May 2022 03:27 UTC

On 5/21/22 10:48 PM, olcott wrote:
> On 5/21/2022 9:37 PM, Richard Damon wrote:
>> On 5/21/22 10:28 PM, olcott wrote:
>>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>>
>>>> On 5/21/22 9:23 PM, olcott wrote:
>>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> You have known that the input to H(P,P) is simulated correctly
>>>>>>>>> proving
>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>
>>>>>>>> If H is intended to be a halt decider (even if only for the one
>>>>>>>> case you
>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P) halts.
>>>>>>>>
>>>>>>>
>>>>>>> When we correctly reverse-engineer what the execution trace of
>>>>>>> the input to H(P,P) would be for one emulation and one nested
>>>>>>> emulation we can see that the correctly emulated input to H(P,P)
>>>>>>> would never reach its final state at machine address [0000136c].
>>>>>>
>>>>>> A nonsense trace, as it is mixing the execution path of two
>>>>>> independent execution units.
>>>>>>
>>>>> In other words you acknowledge that you are technically incompetent
>>>>> to provide the execution trace of one simulation and one nested
>>>>> simulation of the input to H(P,P).
>>>>
>>>> No, I am saying that you are asking for the equivalent of a of a
>>>> square circle.
>>>
>>>
>>> So an execution trace of the input to H(P,P) is easy to show when H
>>> simulates its input, yet another execution trace of the input to
>>> H(P,P) that was invoked by P is "like a square circle" can't possibly
>>> exist?
>>
>> The problem is that your second trace is NOT a piece of the first.
>>
>> The fact you don't understand that says you just don't know how
>> computers or programs actually work.
>>
>
> When a UTM simulates a TM description that calls a UTM that simulates a
> TM description all of this is simply data on the first UTM's tape and
> the only actual executable is the first UTM.

Yes, and a trace made by that outer UTM will show the states that the
second UTM is going through, but NOT the states that second UTM
simulates in its own processing.

That second UTM might produce its OWN trace of the states that it has
simulated, but that is a SEPERATE trace, and NOT part of the trace from
the OUTER UTM.

Finish your TM simulator, and design (or look up) a UTM and try it.

Try to find the execution trace generated by the second UTM actually in
the execution trace of the first UTM, it isn't there, because the first
UTM never actually did that. All you will see is the steps the second
UTM went through to simulate its input.
>
>
>>>
>>> Everyone here (including you) know that is a ridiculously stupid
>>> thing to say. What is you motive for saying these ridiculously stupid
>>> things ?
>>> Are you tying to announce to the world that you are a total numbskull?
>>>
>>
>> Yes, ON YOUR PART. It is stupid to suggest that it is correct to mix
>> the execution trace of different execution contexts as if they were a
>> single context.
>>
>> When you understand that, you might be able to see your error.
>
>

Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<RrSdna_nM600MhT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 21 May 2022 22:36:09 -0500
Date: Sat, 21 May 2022 22:36: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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc> <874k1l8h4u.fsf@bsb.me.uk>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
<MlhiK.9438$kaDc.6185@fx46.iad>
<h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>
<K4iiK.20028$zgr9.11815@fx13.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <K4iiK.20028$zgr9.11815@fx13.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <RrSdna_nM600MhT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 97
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-cxhw9nwUECDKsoI71KdE/fAtcgxxfC7O4kxt4dgBfyrPDSgmgiDQP0MoyvKCS1pFtQgPAYZqNfILp9c!WqcO3rshszHvjDqMNd+gdm4Dd45deExc0kHG3zCc4zbXJf4suLELwmArBX5U1ssoN9XdhjACx+A=
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: 5846
 by: olcott - Sun, 22 May 2022 03:36 UTC

On 5/21/2022 10:27 PM, Richard Damon wrote:
> On 5/21/22 10:48 PM, olcott wrote:
>> On 5/21/2022 9:37 PM, Richard Damon wrote:
>>> On 5/21/22 10:28 PM, olcott wrote:
>>>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>>>
>>>>> On 5/21/22 9:23 PM, olcott wrote:
>>>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> You have known that the input to H(P,P) is simulated correctly
>>>>>>>>>> proving
>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>
>>>>>>>>> If H is intended to be a halt decider (even if only for the one
>>>>>>>>> case you
>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P)
>>>>>>>>> halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When we correctly reverse-engineer what the execution trace of
>>>>>>>> the input to H(P,P) would be for one emulation and one nested
>>>>>>>> emulation we can see that the correctly emulated input to H(P,P)
>>>>>>>> would never reach its final state at machine address [0000136c].
>>>>>>>
>>>>>>> A nonsense trace, as it is mixing the execution path of two
>>>>>>> independent execution units.
>>>>>>>
>>>>>> In other words you acknowledge that you are technically
>>>>>> incompetent to provide the execution trace of one simulation and
>>>>>> one nested simulation of the input to H(P,P).
>>>>>
>>>>> No, I am saying that you are asking for the equivalent of a of a
>>>>> square circle.
>>>>
>>>>
>>>> So an execution trace of the input to H(P,P) is easy to show when H
>>>> simulates its input, yet another execution trace of the input to
>>>> H(P,P) that was invoked by P is "like a square circle" can't
>>>> possibly exist?
>>>
>>> The problem is that your second trace is NOT a piece of the first.
>>>
>>> The fact you don't understand that says you just don't know how
>>> computers or programs actually work.
>>>
>>
>> When a UTM simulates a TM description that calls a UTM that simulates a
>> TM description all of this is simply data on the first UTM's tape and
>> the only actual executable is the first UTM.
>
>
> Yes, and a trace made by that outer UTM will show the states that the
> second UTM is going through, but NOT the states that second UTM
> simulates in its own processing.
>
> That second UTM might produce its OWN trace of the states that it has
> simulated, but that is a SEPERATE trace, and NOT part of the trace from
> the OUTER UTM.
>

And this trace is written to the outer UTM's tape as a part of its own
data.

> Finish your TM simulator, and design (or look up) a UTM and try it.
>
> Try to find the execution trace generated by the second UTM actually in
> the execution trace of the first UTM, it isn't there, because the first
> UTM never actually did that. All you will see is the steps the second
> UTM went through to simulate its input.
>>
>>
>>>>
>>>> Everyone here (including you) know that is a ridiculously stupid
>>>> thing to say. What is you motive for saying these ridiculously
>>>> stupid things ?
>>>> Are you tying to announce to the world that you are a total numbskull?
>>>>
>>>
>>> Yes, ON YOUR PART. It is stupid to suggest that it is correct to mix
>>> the execution trace of different execution contexts as if they were a
>>> single context.
>>>
>>> When you understand that, you might be able to see your error.
>>
>>
>

--
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: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<HtiiK.3779$45E8.1989@fx47.iad>

 copy mid

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

 copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!ecngs!feeder2.ecngs.de!178.20.174.213.MISMATCH!feeder1.feed.usenet.farm!feed.usenet.farm!peer01.ams4!peer.am4.highwinds-media.com!peer03.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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<Y7idnfd_v--hARv_nZ2dnUU7_83NnZ2d@giganews.com>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
<MlhiK.9438$kaDc.6185@fx46.iad>
<h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>
<K4iiK.20028$zgr9.11815@fx13.iad>
<RrSdna_nM600MhT_nZ2dnUU7_8xh4p2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <RrSdna_nM600MhT_nZ2dnUU7_8xh4p2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 115
Message-ID: <HtiiK.3779$45E8.1989@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: Sat, 21 May 2022 23:54:14 -0400
X-Received-Bytes: 6395
 by: Richard Damon - Sun, 22 May 2022 03:54 UTC

On 5/21/22 11:36 PM, olcott wrote:
> On 5/21/2022 10:27 PM, Richard Damon wrote:
>> On 5/21/22 10:48 PM, olcott wrote:
>>> On 5/21/2022 9:37 PM, Richard Damon wrote:
>>>> On 5/21/22 10:28 PM, olcott wrote:
>>>>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 5/21/22 9:23 PM, olcott wrote:
>>>>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> You have known that the input to H(P,P) is simulated
>>>>>>>>>>> correctly proving
>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>
>>>>>>>>>> If H is intended to be a halt decider (even if only for the
>>>>>>>>>> one case you
>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P)
>>>>>>>>>> halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When we correctly reverse-engineer what the execution trace of
>>>>>>>>> the input to H(P,P) would be for one emulation and one nested
>>>>>>>>> emulation we can see that the correctly emulated input to
>>>>>>>>> H(P,P) would never reach its final state at machine address
>>>>>>>>> [0000136c].
>>>>>>>>
>>>>>>>> A nonsense trace, as it is mixing the execution path of two
>>>>>>>> independent execution units.
>>>>>>>>
>>>>>>> In other words you acknowledge that you are technically
>>>>>>> incompetent to provide the execution trace of one simulation and
>>>>>>> one nested simulation of the input to H(P,P).
>>>>>>
>>>>>> No, I am saying that you are asking for the equivalent of a of a
>>>>>> square circle.
>>>>>
>>>>>
>>>>> So an execution trace of the input to H(P,P) is easy to show when H
>>>>> simulates its input, yet another execution trace of the input to
>>>>> H(P,P) that was invoked by P is "like a square circle" can't
>>>>> possibly exist?
>>>>
>>>> The problem is that your second trace is NOT a piece of the first.
>>>>
>>>> The fact you don't understand that says you just don't know how
>>>> computers or programs actually work.
>>>>
>>>
>>> When a UTM simulates a TM description that calls a UTM that simulates a
>>> TM description all of this is simply data on the first UTM's tape and
>>> the only actual executable is the first UTM.
>>
>>
>> Yes, and a trace made by that outer UTM will show the states that the
>> second UTM is going through, but NOT the states that second UTM
>> simulates in its own processing.
>>
>> That second UTM might produce its OWN trace of the states that it has
>> simulated, but that is a SEPERATE trace, and NOT part of the trace
>> from the OUTER UTM.
>>
>
> And this trace is written to the outer UTM's tape as a part of its own
> data.

Yes, the DATA is there, ENCODED on the tape, but it isn't part of the
trace generated by that UTM.

Try it.

Write a UTM that takes as input the representation of a machine and its
tape, and generates at the end a representation of the final state f the
machine, the represntation of the final tape of that computation and a
trace of the execution it performed, and do the experement.

The data from the second level UTM will be in the representation of the
output tape (the output of the second UTM), NOT the section of the tape
with the trace of the execution.

This shows that this second level trace isn't part of the first level
trace, as you want to claim.

You just don't understand how it works, and get the level os
execution/simulation confused.

>
>> Finish your TM simulator, and design (or look up) a UTM and try it.
>>
>> Try to find the execution trace generated by the second UTM actually
>> in the execution trace of the first UTM, it isn't there, because the
>> first UTM never actually did that. All you will see is the steps the
>> second UTM went through to simulate its input.
>>>
>>>
>>>>>
>>>>> Everyone here (including you) know that is a ridiculously stupid
>>>>> thing to say. What is you motive for saying these ridiculously
>>>>> stupid things ?
>>>>> Are you tying to announce to the world that you are a total numbskull?
>>>>>
>>>>
>>>> Yes, ON YOUR PART. It is stupid to suggest that it is correct to mix
>>>> the execution trace of different execution contexts as if they were
>>>> a single context.
>>>>
>>>> When you understand that, you might be able to see your error.
>>>
>>>
>>
>
>

Re: Category error [ HEAD GAMES ] (smart honest people would agree)[ Ben is a Liar ]

<RtudndMn4p2gKBT_nZ2dnUU7_8xh4p2d@giganews.com>

 copy mid

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

 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: Sat, 21 May 2022 22:59:57 -0500
Date: Sat, 21 May 2022 22:59:56 -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: Category error [ HEAD GAMES ] (smart honest people would agree)[
Ben is a Liar ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220514170555.00004550@reddwarf.jmc>
<1K6dnX9xHfmtMxv_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvt6n3s.fsf@bsb.me.uk>
<yeCdnWc-Ja14txr_nZ2dnUU7_83NnZ2d@giganews.com> <877d6g5tuo.fsf@bsb.me.uk>
<A5adnZZH0fB8Nxr_nZ2dnUU7_83NnZ2d@giganews.com> <87k0ag44sa.fsf@bsb.me.uk>
<Q5WdnfJskMwcJRr_nZ2dnUU7_8zNnZ2d@giganews.com> <878rqw41bo.fsf@bsb.me.uk>
<YuSdnW-aUL3WXxr_nZ2dnUU7_83NnZ2d@giganews.com> <87wneg2m2h.fsf@bsb.me.uk>
<jPednedJMZKJWhr_nZ2dnUU7_81g4p2d@giganews.com> <87o7zr3od4.fsf@bsb.me.uk>
<SfWdnTcajIIjkxX_nZ2dnUU7_8zNnZ2d@giganews.com> <87bkvr3kqn.fsf@bsb.me.uk>
<vNmdncQOi5o3ohT_nZ2dnUU7_83NnZ2d@giganews.com>
<r%fiK.28447$J0r9.3351@fx11.iad>
<I6idnSDl8NcUDRT_nZ2dnUU7_83NnZ2d@giganews.com> <s5hiK.45$cq8.28@fx03.iad>
<NtGdndBRE5xLAhT_nZ2dnUU7_83NnZ2d@giganews.com>
<MlhiK.9438$kaDc.6185@fx46.iad>
<h6OdnUIaNIYVORT_nZ2dnUU7_81g4p2d@giganews.com>
<K4iiK.20028$zgr9.11815@fx13.iad>
<RrSdna_nM600MhT_nZ2dnUU7_8xh4p2d@giganews.com>
<HtiiK.3779$45E8.1989@fx47.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <HtiiK.3779$45E8.1989@fx47.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <RtudndMn4p2gKBT_nZ2dnUU7_8xh4p2d@giganews.com>
Lines: 129
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-g96uCd+5HrNIWB/vNxTRMLnK/LU71XthXt23gGA3CkL6CmQ2sZ81T8HAXVT8oukpCZv3czG8a6t9r4W!gRqCo7ReRCk121pn+21N1zo39ir3mGC+QKRxyyjZzP1zYfr7CgXiXFPQeTC4rFzVDHm6P3xbuqg=
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: 7078
 by: olcott - Sun, 22 May 2022 03:59 UTC

On 5/21/2022 10:54 PM, Richard Damon wrote:
> On 5/21/22 11:36 PM, olcott wrote:
>> On 5/21/2022 10:27 PM, Richard Damon wrote:
>>> On 5/21/22 10:48 PM, olcott wrote:
>>>> On 5/21/2022 9:37 PM, Richard Damon wrote:
>>>>> On 5/21/22 10:28 PM, olcott wrote:
>>>>>> On 5/21/2022 9:20 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 5/21/22 9:23 PM, olcott wrote:
>>>>>>>> On 5/21/2022 8:05 PM, Richard Damon wrote:
>>>>>>>>> On 5/21/22 3:38 PM, olcott wrote:
>>>>>>>>>> On 5/20/2022 5:25 PM, Ben wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> You have known that the input to H(P,P) is simulated
>>>>>>>>>>>> correctly proving
>>>>>>>>>>>> that H(P,P)==0 is correct for the whole six months
>>>>>>>>>>>
>>>>>>>>>>> If H is intended to be a halt decider (even if only for the
>>>>>>>>>>> one case you
>>>>>>>>>>> claim to care about) then H(P,P) == 0 is wrong, because P(P)
>>>>>>>>>>> halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When we correctly reverse-engineer what the execution trace of
>>>>>>>>>> the input to H(P,P) would be for one emulation and one nested
>>>>>>>>>> emulation we can see that the correctly emulated input to
>>>>>>>>>> H(P,P) would never reach its final state at machine address
>>>>>>>>>> [0000136c].
>>>>>>>>>
>>>>>>>>> A nonsense trace, as it is mixing the execution path of two
>>>>>>>>> independent execution units.
>>>>>>>>>
>>>>>>>> In other words you acknowledge that you are technically
>>>>>>>> incompetent to provide the execution trace of one simulation and
>>>>>>>> one nested simulation of the input to H(P,P).
>>>>>>>
>>>>>>> No, I am saying that you are asking for the equivalent of a of a
>>>>>>> square circle.
>>>>>>
>>>>>>
>>>>>> So an execution trace of the input to H(P,P) is easy to show when
>>>>>> H simulates its input, yet another execution trace of the input to
>>>>>> H(P,P) that was invoked by P is "like a square circle" can't
>>>>>> possibly exist?
>>>>>
>>>>> The problem is that your second trace is NOT a piece of the first.
>>>>>
>>>>> The fact you don't understand that says you just don't know how
>>>>> computers or programs actually work.
>>>>>
>>>>
>>>> When a UTM simulates a TM description that calls a UTM that simulates a
>>>> TM description all of this is simply data on the first UTM's tape
>>>> and the only actual executable is the first UTM.
>>>
>>>
>>> Yes, and a trace made by that outer UTM will show the states that the
>>> second UTM is going through, but NOT the states that second UTM
>>> simulates in its own processing.
>>>
>>> That second UTM might produce its OWN trace of the states that it has
>>> simulated, but that is a SEPERATE trace, and NOT part of the trace
>>> from the OUTER UTM.
>>>
>>
>> And this trace is written to the outer UTM's tape as a part of its own
>> data.
>
> Yes, the DATA is there, ENCODED on the tape, but it isn't part of the
> trace generated by that UTM.

The only actual executable is the outer UTM everything else is a part of
the same nested process.

>
> Try it.
>
> Write a UTM that takes as input the representation of a machine and its
> tape, and generates at the end a representation of the final state f the
> machine, the represntation of the final tape of that computation and a
> trace of the execution it performed, and do the experement.
>
> The data from the second level UTM will be in the representation of the
> output tape (the output of the second UTM), NOT the section of the tape
> with the trace of the execution.
>
> This shows that this second level trace isn't part of the first level
> trace, as you want to claim.
>
> You just don't understand how it works, and get the level os
> execution/simulation confused.
>
>>
>>> Finish your TM simulator, and design (or look up) a UTM and try it.
>>>
>>> Try to find the execution trace generated by the second UTM actually
>>> in the execution trace of the first UTM, it isn't there, because the
>>> first UTM never actually did that. All you will see is the steps the
>>> second UTM went through to simulate its input.
>>>>
>>>>
>>>>>>
>>>>>> Everyone here (including you) know that is a ridiculously stupid
>>>>>> thing to say. What is you motive for saying these ridiculously
>>>>>> stupid things ?
>>>>>> Are you tying to announce to the world that you are a total
>>>>>> numbskull?
>>>>>>
>>>>>
>>>>> Yes, ON YOUR PART. It is stupid to suggest that it is correct to
>>>>> mix the execution trace of different execution contexts as if they
>>>>> were a single context.
>>>>>
>>>>> When you understand that, you might be able to see your error.
>>>>
>>>>
>>>
>>
>>
>

--
Copyright 2022 Pete Olcott

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

Pages:123456789101112
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor