Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

19 May, 2024: Line wrapping has been changed to be more consistent with Usenet standards.
 If you find that it is broken please let me know here rocksolid.nodes.help

devel / comp.theory / Re: Olcott [ Ben contradicts himself ]

SubjectAuthor
* OlcottMr Flibble
+* Olcottolcott
|+- OlcottMr Flibble
|+- OlcottJeff Barnett
|`* OlcottOtto J. Makela
| `- Olcottolcott
`* OlcottFred. Zwarts
 +* Olcott [good summation]olcott
 |+* Olcott [good summation]Mr Flibble
 ||`* Olcott [good summation]olcott
 || +* Olcott [good summation]Mr Flibble
 || |`* Olcott [good summation]olcott
 || | +* Olcott [good summation]Mr Flibble
 || | |`* Olcott [good summation]olcott
 || | | `- Olcott [good summation]Mr Flibble
 || | `* Olcott [good summation]Richard Damon
 || |  `* Olcott [good summation]olcott
 || |   `* Olcott [good summation]Richard Damon
 || |    `* Olcott [good summation]olcott
 || |     `* Olcott [good summation]Richard Damon
 || |      +* Olcott [good summation]olcott
 || |      |`* Olcott [good summation]Richard Damon
 || |      | `* Olcott [good summation]olcott
 || |      |  `* Olcott [good summation]Richard Damon
 || |      |   +* Olcott [good summation]olcott
 || |      |   |`* Olcott [good summation]Richard Damon
 || |      |   | `* Olcott [good summation]olcott
 || |      |   |  `- Olcott [good summation]Richard Damon
 || |      |   `* Olcott [good summation]olcott
 || |      |    `* Olcott [good summation]Richard Damon
 || |      |     `* Olcott [good summation]olcott
 || |      |      +* Olcott [good summation]Richard Damon
 || |      |      |`* Olcott [good summation]olcott
 || |      |      | +* Olcott [good summation]Richard Damon
 || |      |      | |`* Olcott [good summation]olcott
 || |      |      | | `- Olcott [good summation]Richard Damon
 || |      |      | `* Olcott [good summation]dklei...@gmail.com
 || |      |      |  +- Olcott [good summation]Richard Damon
 || |      |      |  `* Olcott [good summation]olcott
 || |      |      |   `* Olcott [good summation]dklei...@gmail.com
 || |      |      |    +- Olcott [good summation]Ben Bacarisse
 || |      |      |    `- Olcott [good summation]olcott
 || |      |      `* Olcott [good summation]Richard Damon
 || |      |       `* Olcott [good summation]olcott
 || |      |        `- Olcott [good summation]Richard Damon
 || |      `- Olcott [good summation]Jeff Barnett
 || `- Olcott [good summation]Richard Damon
 |+* Olcott [good summation]Fred. Zwarts
 ||+* Olcott [good summation]olcott
 |||+- Olcott [good summation]Mr Flibble
 |||`- Olcott [good summation]Richard Damon
 ||`* Olcott [good summation]Mikko
 || +* Olcott [good summation]Richard Damon
 || |`* Olcott [good summation]Mikko
 || | `- Olcott [good summation]Richard Damon
 || `* Olcott [good summation]olcott
 ||  +- Olcott [good summation]Mikko
 ||  `- Olcott [good summation]Richard Damon
 |`* Olcott [good summation]Mikko
 | +- Olcott [good summation]olcott
 | `- Olcott [good summation]olcott
 +* OlcottRichard Damon
 |`* Olcottolcott
 | `* OlcottRichard Damon
 |  `* Olcottolcott
 |   `* OlcottRichard Damon
 |    `* Olcottolcott
 |     `- OlcottRichard Damon
 +* OlcottBen Bacarisse
 |`* Olcott [ Ben is wrong ]olcott
 | +- Olcott [ Ben is wrong ]Richard Damon
 | +* Olcott [ Ben is wrong ]Shvili, the Kookologist
 | |`* Olcott [ Ben is wrong ]olcott
 | | +- Olcott [ Ben is wrong ]Shvili, the Kookologist
 | | `* Olcott [ Ben is wrong ]Richard Damon
 | |  `* Olcott [ Ben contradicts himself ]olcott
 | |   `* Olcott [ Ben contradicts himself ]Richard Damon
 | |    `* Olcott [ Ben contradicts himself ]olcott
 | |     `* Olcott [ Ben contradicts himself ]Richard Damon
 | |      `* Olcott [ Ben contradicts himself ]olcott
 | |       `* Olcott [ Ben contradicts himself ]Richard Damon
 | |        `* Olcott [ Ben contradicts himself ]olcott
 | |         +* Olcott [ Ben contradicts himself ]Mr Flibble
 | |         |`* Olcott [ Ben contradicts himself ]olcott
 | |         | `* Olcott [ Ben contradicts himself ]Mr Flibble
 | |         |  `* Olcott [ Ben contradicts himself ]olcott
 | |         |   `* Olcott [ Ben contradicts himself ]Mr Flibble
 | |         |    `* Olcott [ Ben contradicts himself ]olcott
 | |         |     `* Olcott [ Ben contradicts himself ]Mr Flibble
 | |         |      +* Olcott [ Ben contradicts himself ]olcott
 | |         |      |`* Olcott [ Ben contradicts himself ]Mr Flibble
 | |         |      | `* Olcott [ Ben contradicts himself ]olcott
 | |         |      |  `* Olcott [ Ben contradicts himself ]Mr Flibble
 | |         |      |   `* Olcott [ Ben contradicts himself ]olcott
 | |         |      |    `- Olcott [ Ben contradicts himself ]Richard Damon
 | |         |      `- Olcott [ Ben contradicts himself ]Skep Dick
 | |         `* Olcott [ Ben contradicts himself ]Richard Damon
 | |          +* Olcott [ Ben contradicts himself ]olcott
 | |          |`* Olcott [ Ben contradicts himself ]Richard Damon
 | |          | `* Olcott [ Ben contradicts himself ] [ SHD defined ]olcott
 | |          |  `* Olcott [ Ben contradicts himself ] [ SHD defined ]Richard Damon
 | |          `* OlcottPaul N
 | `* Olcott [ Ben is wrong ]Shvili, the Kookologist
 `* OlcottMikko

Pages:123456789101112
Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon is just a Troll ]

<_oqdnaWm359X0Zf-nZ2dnZfqlJxh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 16:56:42 +0000
Date: Sat, 27 Aug 2022 11:56:42 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon
is just a Troll ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<Dg5OK.862820$ntj.825969@fx15.iad>
<-ASdnUWSzd60dZX-nZ2dnZfqlJ_NnZ2d@giganews.com>
<GU5OK.856776$70j.99660@fx16.iad>
<JW-dnR36cO3PYJX-nZ2dnZfqlJ_NnZ2d@giganews.com>
<bm7OK.161341$f81.105014@fx43.iad>
<Q8CdnevelfQlkZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<GW8OK.779719$5fVf.536789@fx09.iad>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220827155750.0000056d@reddwarf.jmc.corp>
<8v6dnTcn15-orpf-nZ2dnZfqlJzNnZ2d@giganews.com>
<T0rOK.782932$5fVf.344422@fx09.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <T0rOK.782932$5fVf.344422@fx09.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_oqdnaWm359X0Zf-nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 636
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-8Kf1bpVuKVu1fyEnHXa9YuEon8ufB2c0C1OboD0YtYXsW+Jl4PTA1oIjyTv0T2RN2nkpLGM3ED/BRdY!PZYhrro88RE5KskuJ0RJCS5RF5LYKQlds0zhp7kdO99jYSLC4//Xyd3TGckqgCijZ+ajHZsM8wA=
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
 by: olcott - Sat, 27 Aug 2022 16:56 UTC

On 8/27/2022 10:48 AM, Richard Damon wrote:
> On 8/27/22 11:07 AM, olcott wrote:
>> On 8/27/2022 9:57 AM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 09:48:21 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution trace
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P) (d)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0((u32)Infinite_Loop)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a
>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of this partial
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
>>>>>>>>>>>>>>>>>>>>>>>> entirely different behavior
>>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P, P)
>>>>>>>>>>>>>>>>>>>>>>> has some sort of "input" which is not P is
>>>>>>>>>>>>>>>>>>>>>>> nonsense.
>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (d) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you
>>>>>>>>>>>>>>>>>>>>>>> twice in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation of
>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
>>>>>>>>>>>>>>>>>>>>>> complete simulation of the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>>>> shown by replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>         int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>         if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>           HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>         return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>         Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do
>>>>>>>>>>>>>>>>>>>>>>> simply by working out what a non-aborting H would
>>>>>>>>>>>>>>>>>>>>>>> do and pretending a different H will do the same
>>>>>>>>>>>>>>>>>>>>>>> thing.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT
>>>>>>>>>>>>>>>>>>>>>> WHAT A NON-ABORTING SHD WOULD DO. That is what
>>>>>>>>>>>>>>>>>>>>>> they are supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would do,
>>>>>>>>>>>>>>>>>>>>> AS IS.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs
>>>>>>>>>>>>>>>>>>>>> aren't actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>       > On Monday, July 25, 2022 at 12:10:34 AM
>>>>>>>>>>>>>>>>>>>>>>       > UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>       >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>>>>>>       >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>>       >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>       >> pattern then this SHD is necessarily
>>>>>>>>>>>>>>>>>>>>>>       >> correct when it aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>       >> reports non-halting.
>>>>>>>>>>>>>>>>>>>>>>       >
>>>>>>>>>>>>>>>>>>>>>>       > Yes, *If* a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>       > continues to correctly simulate its input
>>>>>>>>>>>>>>>>>>>>>>       > until it *correctly* matches a non- halting
>>>>>>>>>>>>>>>>>>>>>>       > behaviour pattern then this SHD is correct
>>>>>>>>>>>>>>>>>>>>>>       > when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>>>       > non-halting. [*some content snipped to stay
>>>>>>>>>>>>>>>>>>>>>>       > focused on this point*]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
>>>>>>>>>>>>>>>>>>>>>> behavior of its input if H never aborted the
>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>         Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state
>>>>>>>>>>>>>>>>>>>>>>>>>> of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and stops,
>>>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence ploughs
>>>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1,
>>>>>>>>>>>>>>>>>>>>> but it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>         int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>>>>         if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>           HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>         return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct
>>>>>>>>>>>>>>>>>>>>>>> answers. My simulation is correct. My simulation
>>>>>>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
>>>>>>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt, and
>>>>>>>>>>>>>>>>>>>>>>> that H(P, P) = 0 is an acceptable answer."
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
>>>>>>>>>>>>>>>>>>>>>>> simulation gives different results from the
>>>>>>>>>>>>>>>>>>>>>>> directly executed function, but instead of
>>>>>>>>>>>>>>>>>>>>>>> recognising that this proves your simulator is
>>>>>>>>>>>>>>>>>>>>>>> incorrect, you feel justified in rejecting the
>>>>>>>>>>>>>>>>>>>>>>> actual results actually produced by the function
>>>>>>>>>>>>>>>>>>>>>>> in favour of your "correct simulation".
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so H(P,P)
>>>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any
>>>>>>>>>>>>>>>>>>>>> more right.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
>>>>>>>>>>>>>>>>>>>> set up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept
>>>>>>>>>>>>>>>>>>>> at using the strawman deception that gullible fools
>>>>>>>>>>>>>>>>>>>> accept your deceitful attempts at rebuttal as
>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>>>>> simulation of a machine description always provides
>>>>>>>>>>>>>>>>>>>> the actual behavior specified by this machine
>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>> correctly performs a partial simulation of its input
>>>>>>>>>>>>>>>>>>>> and the behavior of this partial simulation
>>>>>>>>>>>>>>>>>>>> correctly matches a correct non-halting behavior
>>>>>>>>>>>>>>>>>>>> pattern then the SHD halt decider can correctly
>>>>>>>>>>>>>>>>>>>> report non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided
>>>>>>>>>>>>>>>>>>> one that you have actually proved is correct for this
>>>>>>>>>>>>>>>>>>> case.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>> when-so-ever matching this behavior pattern proves
>>>>>>>>>>>>>>>>>>>> that the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID
>>>>>>>>>>>>>>>>>>> definition. Note, you can't change the SHD to be a
>>>>>>>>>>>>>>>>>>> different machine if doing so changes the code at the
>>>>>>>>>>>>>>>>>>> input, which includes ALL the code that P calls, not
>>>>>>>>>>>>>>>>>>> just the code inside the "C function" of P.
>>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt deciders
>>>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
>>>>>>>>>>>>>>>>>>> behavior of its input, but only the behavior of some
>>>>>>>>>>>>>>>>>>> other input built on a different H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
>>>>>>>>>>>>>>>> supporting reasoning.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
>>>>>>>>>>>>>>> understand because you are too stupid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>>>> A halt decider must always derive its halt status
>>>>>>>>>>>>>>>> decision on the basis of the actual behavior of the
>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>>>>>> "actual input" for an x86 decider is what happens when you
>>>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>>>>> would be the correct and complete simulation of the input
>>>>>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>>>>> not as executed "At that point in the execution trace",
>>>>>>>>>>>>>>> but as an actual computation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don;t think you know enough about how a program works to
>>>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>         int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
>>>>>>>>>>>>> simulation of the input to H, it wanted a halting decision
>>>>>>>>>>>>> that corresponded to that behavior, and it whated that in
>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, replacing the call to H with a simulation of the input
>>>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is the job of H to correctly predict what the behavior
>>>>>>>>>>>>>> of its input would be if H performed a correct and complete
>>>>>>>>>>>>>> simulation of this input:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, it is to correct predict what the behavior of its
>>>>>>>>>>>>> input would be if given to a correct and complete
>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>
>>>>>>>>>>>>> But doesn't do a correct and complete simulation of its
>>>>>>>>>>>>> input, so it didn't establish the needed criteria.
>>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN
>>>>>>>>>>>> REPEATED MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
>>>>>>>>>>>> HAVE ACTUAL BRAIN DAMAGE.
>>>>>>>>>>>>
>>>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>>>
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>>>>>> and on)
>>>>>>>>>>>
>>>>>>>>>>> You've told us numerous times that H does not do this - you
>>>>>>>>>>> have even explained why it does not do this. So H is not
>>>>>>>>>>> simulating itself correctly.
>>>>>>>>>>
>>>>>>>>>> I could have equally been told many times that cats are a kind
>>>>>>>>>> of dog, that does not make it true.
>>>>>>>>>>
>>>>>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>>>>>> its input would be if a correct and complete simulation of this
>>>>>>>>>> input was performed at the exact same place in the execution
>>>>>>>>>> trace where H is invoked.
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>        return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and
>>>>>>>>>> on)
>>>>>>>>>
>>>>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>>>>> performing a "correct and complete simulation of this input".  H
>>>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>>>
>>>>>>>>> void Px(ptr x)
>>>>>>>>> {
>>>>>>>>>       (void)H(x, x);
>>>>>>>>>       return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>>>>> correctly simulates its input that the "return" instruction is
>>>>>>>> unreachable code by this simulated input.
>>>>>>>
>>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>>>>> that as a halt decider is supposed to return a decision to its
>>>>>>> caller (Px in this case).
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>>> final state:
>>>>>>
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>>       H(x, x);
>>>>>>       return;
>>>>>> }
>>>>>>
>>>>>> void Py(u32 x)
>>>>>> {
>>>>>>       Simulate(x, x);
>>>>>>       return;
>>>>>> }
>>>>>>
>>>>>> void Pz(u32 x)
>>>>>> {
>>>>>>       UTM(x, x);
>>>>>>       return;
>>>>>> }
>>>>>
>>>>> Error by non-equivalence: a halt decider (i.e. H) is supposed to
>>>>> return a result to its caller in finite time.
>>>>>
>>>>> /Flibble
>>>>
>>>> The outermost H returns to its caller, the first inner H is aborted
>>>> before it is even invoked.
>>>
>>> Which means the input is not completely, correctly simulated contrary
>>> to what you keep claiming.
>>>
>>> /Flibble
>>>
>>
>> It
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> what the behavior of the correct and complete simulation
>> would be without actually doing a complete simulation.
>>
>> You too must be a brain dead moron, I have explained this hundreds of
>> times.
>>
>
> And predicts wrong.
>
> H(Px,Px) Never DOES a complete simulation so anything H predicts about
> what that does is wrong, and is just engaging in mythology.
>
> UTM(Px,Px) halts, so that proves that the complete simulation of the
> input would halt.


Click here to read the complete article
Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon is just a Troll ]

<_oqdnaSm359A0Zf-nZ2dnZfqlJxh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!tncsrv06.tnetconsulting.net!1.us.feeder.erje.net!feeder.erje.net!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 16:57:01 +0000
Date: Sat, 27 Aug 2022 11:57:01 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon
is just a Troll ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<BtdOK.854831$zgr9.553792@fx13.iad>
<8L2dnUzNvpSE6pT-nZ2dnZfqlJzNnZ2d@giganews.com>
<JTeOK.779769$5fVf.720211@fx09.iad> <tebvvr$71l4$1@dont-email.me>
<VzfOK.856983$70j.574433@fx16.iad>
<hO-dnZUiK_MoEpT-nZ2dnZfqlJ_NnZ2d@giganews.com>
<bEmOK.904472$wIO9.136373@fx12.iad>
<nu2dnfJ87rWds5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<qeqOK.883263$70j.139939@fx16.iad>
<ScedncxTAcBfrJf-nZ2dnZfqlJxh4p2d@giganews.com>
<KqqOK.782615$5fVf.534435@fx09.iad>
<8v6dnTYn15_vrpf-nZ2dnZfqlJxh4p2d@giganews.com>
<e5rOK.109475$BZ1.27530@fx03.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <e5rOK.109475$BZ1.27530@fx03.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_oqdnaSm359A0Zf-nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 137
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-k9w6FPP0H9Ji+8fkhUhjr6F4j93WVb4mG6MMJibEHE5QS2iQaNkklu7LMrPW4RGcaOFFipL0Ye1qh9P!dQInr3K3Suai+UwRs9bIa0sd4POzilZKFyLPyFyen7KuuLKVF4XrMETgSsEnF5bBQntf98JEy/Y=
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
 by: olcott - Sat, 27 Aug 2022 16:57 UTC

On 8/27/2022 10:52 AM, Richard Damon wrote:
>
> On 8/27/22 11:08 AM, olcott wrote:
>> On 8/27/2022 10:07 AM, Richard Damon wrote:
>>> On 8/27/22 11:01 AM, olcott wrote:
>>>> On 8/27/2022 9:54 AM, Richard Damon wrote:
>>>>> On 8/27/22 10:45 AM, olcott wrote:
>>>>>> On 8/27/2022 5:48 AM, Richard Damon wrote:
>>>>>>> On 8/26/22 11:29 PM, olcott wrote:
>>>>>>>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/26/22 10:36 PM, olcott wrote:
>>>>>>>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>>>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>>>> In none of these cases will the simulated P(P) ever reach
>>>>>>>>>>>>>> its own final state:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>>>>     return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY Simulated,
>>>>>>>>>>>>> since H(Px,Px) has been shown to return 0 in finite time.
>>>>>>>>>>>>
>>>>>>>>>>>> So maybe you are as clueless as Flibble.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>>
>>>>>>>>>>>> Whether H simulates its input once or allows the recursive
>>>>>>>>>>>> simulations to continue forever there is never a case where
>>>>>>>>>>>> simulated Px ever reaches its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> When H aborts its simulated input it never again simulates a
>>>>>>>>>>>> single instruction of its input thus all recursive
>>>>>>>>>>>> emulations are immediately dead in the water and cannot
>>>>>>>>>>>> return to their caller.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, it doesn't. May be you don't know your own code, or you
>>>>>>>>>>> are just a LIAR.
>>>>>>>>>>>
>>>>>>>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at
>>>>>>>>>>> which point the original H(P,P) aborts its simulation and
>>>>>>>>>>> returns 0.
>>>>>>>>>>>
>>>>>>>>>>> THAT is what you code does.
>>>>>>>>>>>
>>>>>>>>>>> That means that a CORRECT and *COMPLETE* simulation of the
>>>>>>>>>>> input to H(P,P) is:
>>>>>>>>>>>
>>>>>>>>>>> Simulator simulated P(P) calling H(P,P).
>>>>>>>>>>> That H(P,P) is simulated to simulate a copy of P(P), and will
>>>>>>>>>>> simulate to it calling H(P,P).
>>>>>>>>>>> That simulated H(P,P) then aborts its simulation and is
>>>>>>>>>>> simulated to return to the P(P) that the outer simulation is
>>>>>>>>>>> simulating.
>>>>>>>>>>>
>>>>>>>>>>> THat simulated P(P) will reach its final state and return.
>>>>>>>>>>>
>>>>>>>>>>> Please point out the error in that description.
>>>>>>>>>>
>>>>>>>>>> The executed H(P,P) simulates P(P) that calls the simulated
>>>>>>>>>> H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> until the executed H(P,P) aborts the whole chain causing
>>>>>>>>>> everything else to immediately stop.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, I said that, and the correct and complete simulation of the
>>>>>>>>> input sees that in the simulate call to H(P,P) and then sees
>>>>>>>>> the simulate P(P) reaching its final state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *You just don't seem to know enough about software engineering*
>>>>>>>> When the outermost executed H(P,P) aborts the simulation of its
>>>>>>>> input all of the simulations immediately stop because it was
>>>>>>>> only the outermost H that was driving them.
>>>>>>>>
>>>>>>>>  From the simulated P's point of view it is just like it hit an
>>>>>>>> abnormal termination core dump divide by zero error. No more
>>>>>>>> steps are simulated.
>>>>>>>>
>>>>>>>
>>>>>>> No, you have your details wrong, at least if you intend to be
>>>>>>> working on the Halting Problem. When H stops its simulation, the
>>>>>>> SIMULATION stops, but the behavior of the simulated P doesn't
>>>>>>> "stop", it just becomes unknown.
>>>>>>
>>>>>> You are totally incompetent about this.
>>>>>>
>>>>>>
>>>>>
>>>>> Then you can point out an actual error, or are YOU the incompetent
>>>>> one?
>>>> When a simulator quits simulating the simulated becomes static data
>>>> and stops running.
>>>>
>>>
>>> Shows you don't understand simulation,
>>
>> Shows that you and Flibble should be put back on blocked.
>>
>
> Just means that you won't be able to try to defend your lies from the
> light I put on it.
>
> That means if you DO get up the courage to try to publish, and the
> review searches and find all these discussions, they can come back and
> ask why you didn't deal with the problems pointed out to you.
>
> Note, once you submit, you can't just change your tack with your
> arguement, so you really need to work out the bugs first.
>
> Nothing I point out won't also get pointed out by the reviewer. You
> might not think so, but they will.

--
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: Olcott [Paul N does care about facts and truth ] [ Flibble is clueless about software engineering ]

<_oqdnaem35-S0Jf-nZ2dnZfqlJxh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 16:57:51 +0000
Date: Sat, 27 Aug 2022 11:57:51 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott [Paul N does care about facts and truth ] [ Flibble is
clueless about software engineering ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<BtdOK.854831$zgr9.553792@fx13.iad>
<8L2dnUzNvpSE6pT-nZ2dnZfqlJzNnZ2d@giganews.com>
<JTeOK.779769$5fVf.720211@fx09.iad> <tebvvr$71l4$1@dont-email.me>
<VzfOK.856983$70j.574433@fx16.iad>
<hO-dnZUiK_MoEpT-nZ2dnZfqlJ_NnZ2d@giganews.com>
<bEmOK.904472$wIO9.136373@fx12.iad>
<nu2dnfJ87rWds5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<qeqOK.883263$70j.139939@fx16.iad>
<ScedncxTAcBfrJf-nZ2dnZfqlJxh4p2d@giganews.com>
<KqqOK.782615$5fVf.534435@fx09.iad>
<8v6dnTYn15_vrpf-nZ2dnZfqlJxh4p2d@giganews.com>
<20220827165835.00006de0@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220827165835.00006de0@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <_oqdnaem35-S0Jf-nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 132
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lFlK8NIqDddN2oTVJ/wh5cYtns3/EAPrd2F9g1fUqaRgSGK1bT+J6G9QmM0Vv1AmEqdMkeFTzAIhW0/!Qq9tNLsdwhOHt4o3MSBV6FSZaUS7dFXEvXfiOEPt6awGTwk0SWgaEJD9ndFhYPk2ieRTuW1CBBs=
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
 by: olcott - Sat, 27 Aug 2022 16:57 UTC

On 8/27/2022 10:58 AM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 10:08:34 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 10:07 AM, Richard Damon wrote:
>>> On 8/27/22 11:01 AM, olcott wrote:
>>>> On 8/27/2022 9:54 AM, Richard Damon wrote:
>>>>> On 8/27/22 10:45 AM, olcott wrote:
>>>>>> On 8/27/2022 5:48 AM, Richard Damon wrote:
>>>>>>> On 8/26/22 11:29 PM, olcott wrote:
>>>>>>>> On 8/26/2022 9:46 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/26/22 10:36 PM, olcott wrote:
>>>>>>>>>> On 8/26/2022 8:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 8/26/22 9:44 PM, olcott wrote:
>>>>>>>>>>>> On 8/26/2022 7:22 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/26/22 8:13 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>>>> In none of these cases will the simulated P(P) ever
>>>>>>>>>>>>>> reach its own final state:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>>>>     return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> ^ This will when it is CORRECTLY and COMPLETELY
>>>>>>>>>>>>> Simulated, since H(Px,Px) has been shown to return 0 in
>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>
>>>>>>>>>>>> So maybe you are as clueless as Flibble.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>>
>>>>>>>>>>>> Whether H simulates its input once or allows the recursive
>>>>>>>>>>>> simulations to continue forever there is never a case
>>>>>>>>>>>> where simulated Px ever reaches its final state.
>>>>>>>>>>>>
>>>>>>>>>>>> When H aborts its simulated input it never again simulates
>>>>>>>>>>>> a single instruction of its input thus all recursive
>>>>>>>>>>>> emulations are immediately dead in the water and cannot
>>>>>>>>>>>> return to their caller.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> No, it doesn't. May be you don't know your own code, or you
>>>>>>>>>>> are just a LIAR.
>>>>>>>>>>>
>>>>>>>>>>> H(P,P) simulates P(P), and that calls a simulate H(P,P) at
>>>>>>>>>>> which point the original H(P,P) aborts its simulation and
>>>>>>>>>>> returns 0.
>>>>>>>>>>>
>>>>>>>>>>> THAT is what you code does.
>>>>>>>>>>>
>>>>>>>>>>> That means that a CORRECT and *COMPLETE* simulation of the
>>>>>>>>>>> input to H(P,P) is:
>>>>>>>>>>>
>>>>>>>>>>> Simulator simulated P(P) calling H(P,P).
>>>>>>>>>>> That H(P,P) is simulated to simulate a copy of P(P), and
>>>>>>>>>>> will simulate to it calling H(P,P).
>>>>>>>>>>> That simulated H(P,P) then aborts its simulation and is
>>>>>>>>>>> simulated to return to the P(P) that the outer simulation
>>>>>>>>>>> is simulating.
>>>>>>>>>>>
>>>>>>>>>>> THat simulated P(P) will reach its final state and return.
>>>>>>>>>>>
>>>>>>>>>>> Please point out the error in that description.
>>>>>>>>>>
>>>>>>>>>> The executed H(P,P) simulates P(P) that calls the simulated
>>>>>>>>>> H(P,P) that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> that simulates P(P) that calls the simulated H(P,P)
>>>>>>>>>> until the executed H(P,P) aborts the whole chain causing
>>>>>>>>>> everything else to immediately stop.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> So, I said that, and the correct and complete simulation of
>>>>>>>>> the input sees that in the simulate call to H(P,P) and then
>>>>>>>>> sees the simulate P(P) reaching its final state.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *You just don't seem to know enough about software engineering*
>>>>>>>> When the outermost executed H(P,P) aborts the simulation of
>>>>>>>> its input all of the simulations immediately stop because it
>>>>>>>> was only the outermost H that was driving them.
>>>>>>>>
>>>>>>>>  From the simulated P's point of view it is just like it hit
>>>>>>>> an abnormal termination core dump divide by zero error. No
>>>>>>>> more steps are simulated.
>>>>>>>>
>>>>>>>
>>>>>>> No, you have your details wrong, at least if you intend to be
>>>>>>> working on the Halting Problem. When H stops its simulation,
>>>>>>> the SIMULATION stops, but the behavior of the simulated P
>>>>>>> doesn't "stop", it just becomes unknown.
>>>>>>
>>>>>> You are totally incompetent about this.
>>>>>>
>>>>>>
>>>>>
>>>>> Then you can point out an actual error, or are YOU the
>>>>> incompetent one?
>>>> When a simulator quits simulating the simulated becomes static
>>>> data and stops running.
>>>>
>>>
>>> Shows you don't understand simulation,
>>
>> Shows that you and Flibble should be put back on blocked.
>
> Blocking me will make no difference as I will continue to point out
> your errors and you will continue to ignore those errors but for a
> different reason (i.e. no longer being able to see them in this forum as
> opposed to stubbornly refusing to address them honestly).
>
> /Flibble
>

--
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: Olcott [Paul N does care about facts and truth ] [ Flibble is clueless about software engineering ]

<_oqdnaGm35_u0Jf-nZ2dnZfqlJxh4p2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 16:59:31 +0000
Date: Sat, 27 Aug 2022 11:59:31 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott [Paul N does care about facts and truth ] [ Flibble is
clueless about software engineering ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<Dg5OK.862820$ntj.825969@fx15.iad>
<-ASdnUWSzd60dZX-nZ2dnZfqlJ_NnZ2d@giganews.com>
<GU5OK.856776$70j.99660@fx16.iad>
<JW-dnR36cO3PYJX-nZ2dnZfqlJ_NnZ2d@giganews.com>
<bm7OK.161341$f81.105014@fx43.iad>
<Q8CdnevelfQlkZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<GW8OK.779719$5fVf.536789@fx09.iad>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<20220827155750.0000056d@reddwarf.jmc.corp>
<8v6dnTcn15-orpf-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827164541.00005c70@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220827164541.00005c70@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <_oqdnaGm35_u0Jf-nZ2dnZfqlJxh4p2d@giganews.com>
Lines: 680
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-xqpFrvghRl2vp2Itj4ZKNsX6DgENvcWGJWaSwXCBOghf428RxrBGp3EQKN9AXnPMsaPFTH5ftLtEi9W!hdpX4tdlnpLMPvqCQv1cC5ryL51OxUag2T9iejuwkvnP8Is0bDHewuTMaakPBfPvDeuOUSHc7sc=
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
 by: olcott - Sat, 27 Aug 2022 16:59 UTC

On 8/27/2022 10:45 AM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 10:07:32 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 9:57 AM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 09:48:21 -0500
>>> olcott <NoOne@NoWhere.com> wrote:
>>>
>>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>
>>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>
>>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>
>>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott
>>>>>>>>>>> wrote:
>>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM
>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 3:50:37
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trace of the simulation of the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by H(P,P) exactly matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> line-by-line the x86 source-code of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P and this shows that the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never reaches its final state
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and stops running: (a) H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (d) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0((u32)Infinite_Loop)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> a machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a
>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior of this partial
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
>>>>>>>>>>>>>>>>>>>>>>>> entirely different behavior
>>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its
>>>>>>>>>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is
>>>>>>>>>>>>>>>>>>>>>>> P and so H must report on what P does. The
>>>>>>>>>>>>>>>>>>>>>>> second argument is also P and so specifically H
>>>>>>>>>>>>>>>>>>>>>>> must report on what P(P) does. The idea that
>>>>>>>>>>>>>>>>>>>>>>> H(P, P) has some sort of "input" which is not P
>>>>>>>>>>>>>>>>>>>>>>> is nonsense.
>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (c) that simulates
>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P) (d) that
>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you
>>>>>>>>>>>>>>>>>>>>>>> twice in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE simulation
>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) would do. A correct and
>>>>>>>>>>>>>>>>>>>>>> complete simulation of the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>>>> shown by replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do
>>>>>>>>>>>>>>>>>>>>>>> simply by working out what a non-aborting H
>>>>>>>>>>>>>>>>>>>>>>> would do and pretending a different H will do
>>>>>>>>>>>>>>>>>>>>>>> the same thing.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT
>>>>>>>>>>>>>>>>>>>>>> WHAT A NON-ABORTING SHD WOULD DO. That is what
>>>>>>>>>>>>>>>>>>>>>> they are supposed to do and that is how they
>>>>>>>>>>>>>>>>>>>>>> work.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would
>>>>>>>>>>>>>>>>>>>>> do, AS IS.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs
>>>>>>>>>>>>>>>>>>>>> aren't actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>> > On Monday, July 25, 2022 at 12:10:34 AM
>>>>>>>>>>>>>>>>>>>>>> > UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> >> If a simulating halt decider continues
>>>>>>>>>>>>>>>>>>>>>> >> to correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>> >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>>>> >> pattern then this SHD is necessarily
>>>>>>>>>>>>>>>>>>>>>> >> correct when it aborts its simulation
>>>>>>>>>>>>>>>>>>>>>> >> and reports non-halting.
>>>>>>>>>>>>>>>>>>>>>> >
>>>>>>>>>>>>>>>>>>>>>> > Yes, *If* a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>> > continues to correctly simulate its input
>>>>>>>>>>>>>>>>>>>>>> > until it *correctly* matches a non-
>>>>>>>>>>>>>>>>>>>>>> > halting behaviour pattern then this SHD
>>>>>>>>>>>>>>>>>>>>>> > is correct when it aborts its simulation
>>>>>>>>>>>>>>>>>>>>>> > and reports non-halting. [*some content
>>>>>>>>>>>>>>>>>>>>>> > snipped to stay focused on this point*]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact
>>>>>>>>>>>>>>>>>>>>> that the correct answer doesn't actually depend
>>>>>>>>>>>>>>>>>>>>> on the behavior of H0 say you can "get away" with
>>>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
>>>>>>>>>>>>>>>>>>>>>> behavior of its input if H never aborted the
>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact
>>>>>>>>>>>>>>>>>>>>> that the correct answer doesn't actually depend
>>>>>>>>>>>>>>>>>>>>> on the behavior of H1 say you can "get away" with
>>>>>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it
>>>>>>>>>>>>>>>>>>>>> H never aborted it, since H does abort it, so you
>>>>>>>>>>>>>>>>>>>>> are asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final
>>>>>>>>>>>>>>>>>>>>>>>>>> state of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and
>>>>>>>>>>>>>>>>>>>>>>>>> stops, it is not correct to pretend that H
>>>>>>>>>>>>>>>>>>>>>>>>> never realises it is stuck in a loop and
>>>>>>>>>>>>>>>>>>>>>>>>> hence ploughs on regardless.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the
>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state
>>>>>>>>>>>>>>>>>>>>>>>> of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times
>>>>>>>>>>>>>>>>>>>>>>> you must realise you're pulling a fast one
>>>>>>>>>>>>>>>>>>>>>>> here. You claim that P(P) halts. However, you
>>>>>>>>>>>>>>>>>>>>>>> are trying to run an argument along the
>>>>>>>>>>>>>>>>>>>>>>> following lines:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return 1,
>>>>>>>>>>>>>>>>>>>>> but it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>>>> if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>> return;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct
>>>>>>>>>>>>>>>>>>>>>>> answers. My simulation is correct. My simulation
>>>>>>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
>>>>>>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt, and
>>>>>>>>>>>>>>>>>>>>>>> that H(P, P) = 0 is an acceptable answer."
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed
>>>>>>>>>>>>>>>>>>>>> by sound and valid logic will give the corret
>>>>>>>>>>>>>>>>>>>>> answer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
>>>>>>>>>>>>>>>>>>>>>>> simulation gives different results from the
>>>>>>>>>>>>>>>>>>>>>>> directly executed function, but instead of
>>>>>>>>>>>>>>>>>>>>>>> recognising that this proves your simulator is
>>>>>>>>>>>>>>>>>>>>>>> incorrect, you feel justified in rejecting the
>>>>>>>>>>>>>>>>>>>>>>> actual results actually produced by the function
>>>>>>>>>>>>>>>>>>>>>>> in favour of your "correct simulation".
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>> SIMULATION H ALWAYS REPORTS ON THE BEHAVIOR OF
>>>>>>>>>>>>>>>>>>>>>> PURE SIMULATION H ALWAYS REPORTS ON THE BEHAVIOR
>>>>>>>>>>>>>>>>>>>>>> OF PURE SIMULATION H ALWAYS REPORTS ON THE
>>>>>>>>>>>>>>>>>>>>>> BEHAVIOR OF PURE SIMULATION H ALWAYS REPORTS ON
>>>>>>>>>>>>>>>>>>>>>> THE BEHAVIOR OF PURE SIMULATION
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so
>>>>>>>>>>>>>>>>>>>>> H(P,P) is wrong.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any
>>>>>>>>>>>>>>>>>>>>> more right.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that is
>>>>>>>>>>>>>>>>>>>> set up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so adept
>>>>>>>>>>>>>>>>>>>> at using the strawman deception that gullible fools
>>>>>>>>>>>>>>>>>>>> accept your deceitful attempts at rebuttal as
>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
>>>>>>>>>>>>>>>>>>>> complete simulation of a machine description
>>>>>>>>>>>>>>>>>>>> always provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>> correctly performs a partial simulation of its
>>>>>>>>>>>>>>>>>>>> input and the behavior of this partial simulation
>>>>>>>>>>>>>>>>>>>> correctly matches a correct non-halting behavior
>>>>>>>>>>>>>>>>>>>> pattern then the SHD halt decider can correctly
>>>>>>>>>>>>>>>>>>>> report non-halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't provided
>>>>>>>>>>>>>>>>>>> one that you have actually proved is correct for
>>>>>>>>>>>>>>>>>>> this case.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>> when-so-ever matching this behavior pattern proves
>>>>>>>>>>>>>>>>>>>> that the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final state of
>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and
>>>>>>>>>>>>>>>>>>> correct simulation of thd input, that is an INVALID
>>>>>>>>>>>>>>>>>>> definition. Note, you can't change the SHD to be a
>>>>>>>>>>>>>>>>>>> different machine if doing so changes the code at
>>>>>>>>>>>>>>>>>>> the input, which includes ALL the code that P
>>>>>>>>>>>>>>>>>>> calls, not just the code inside the "C function" of
>>>>>>>>>>>>>>>>>>> P.
>>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt
>>>>>>>>>>>>>>>>>>>> deciders must abort the simulation of inputs that
>>>>>>>>>>>>>>>>>>>> would never otherwise halt. Here are three
>>>>>>>>>>>>>>>>>>>> examples of that:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
>>>>>>>>>>>>>>>>>>> behavior of its input, but only the behavior of some
>>>>>>>>>>>>>>>>>>> other input built on a different H.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
>>>>>>>>>>>>>>>> supporting reasoning.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
>>>>>>>>>>>>>>> understand because you are too stupid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>>>> A halt decider must always derive its halt status
>>>>>>>>>>>>>>>> decision on the basis of the actual behavior of the
>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of
>>>>>>>>>>>>>>> the "actual input" for an x86 decider is what happens
>>>>>>>>>>>>>>> when you run that actual input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>>>>> would be the correct and complete simulation of the
>>>>>>>>>>>>>>>> input to H(P,P) at the exact same point in the
>>>>>>>>>>>>>>>> execution trace where H is invoked:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>>>>> not as executed "At that point in the execution trace",
>>>>>>>>>>>>>>> but as an actual computation.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don;t think you know enough about how a program works
>>>>>>>>>>>>>>> to get into a beginners programming course.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
>>>>>>>>>>>>> simulation of the input to H, it wanted a halting decision
>>>>>>>>>>>>> that corresponded to that behavior, and it whated that in
>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, replacing the call to H with a simulation of the
>>>>>>>>>>>>> input to H is not a correct substitution.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is the job of H to correctly predict what the behavior
>>>>>>>>>>>>>> of its input would be if H performed a correct and
>>>>>>>>>>>>>> complete simulation of this input:
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, it is to correct predict what the behavior of its
>>>>>>>>>>>>> input would be if given to a correct and complete
>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of
>>>>>>>>>>>>> its input, you statement is nonsence.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But doesn't do a correct and complete simulation of its
>>>>>>>>>>>>> input, so it didn't establish the needed criteria.
>>>>>>>>>>>>>
>>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN
>>>>>>>>>>>> REPEATED MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
>>>>>>>>>>>> HAVE ACTUAL BRAIN DAMAGE.
>>>>>>>>>>>>
>>>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>>>
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> PREDICT
>>>>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>> (on and on)
>>>>>>>>>>>
>>>>>>>>>>> You've told us numerous times that H does not do this - you
>>>>>>>>>>> have even explained why it does not do this. So H is not
>>>>>>>>>>> simulating itself correctly.
>>>>>>>>>>
>>>>>>>>>> I could have equally been told many times that cats are a
>>>>>>>>>> kind of dog, that does not make it true.
>>>>>>>>>>
>>>>>>>>>> A simulating halt decider always predicts what the behavior
>>>>>>>>>> of its input would be if a correct and complete simulation
>>>>>>>>>> of this input was performed at the exact same place in the
>>>>>>>>>> execution trace where H is invoked.
>>>>>>>>>>
>>>>>>>>>> void P(ptr x)
>>>>>>>>>> {
>>>>>>>>>> int Halt_Status = Simulate(x, x);
>>>>>>>>>> if (Halt_Status)
>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>> return;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and
>>>>>>>>>> on)
>>>>>>>>>
>>>>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>>>>> performing a "correct and complete simulation of this input".
>>>>>>>>> H deciding the following is non-halting is an ERROR:
>>>>>>>>>
>>>>>>>>> void Px(ptr x)
>>>>>>>>> {
>>>>>>>>> (void)H(x, x);
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>>>>> correctly simulates its input that the "return" instruction is
>>>>>>>> unreachable code by this simulated input.
>>>>>>>
>>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>>>>> that as a halt decider is supposed to return a decision to its
>>>>>>> caller (Px in this case).
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>>> final state:
>>>>>>
>>>>>> void Px(u32 x)
>>>>>> {
>>>>>> H(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> void Py(u32 x)
>>>>>> {
>>>>>> Simulate(x, x);
>>>>>> return;
>>>>>> }
>>>>>>
>>>>>> void Pz(u32 x)
>>>>>> {
>>>>>> UTM(x, x);
>>>>>> return;
>>>>>> }
>>>>>
>>>>> Error by non-equivalence: a halt decider (i.e. H) is supposed to
>>>>> return a result to its caller in finite time.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> The outermost H returns to its caller, the first inner H is aborted
>>>> before it is even invoked.
>>>
>>> Which means the input is not completely, correctly simulated
>>> contrary to what you keep claiming.
>>>
>>> /Flibble
>>>
>>
>> It
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> PREDICTS
>> what the behavior of the correct and complete simulation
>> would be without actually doing a complete simulation.
>>
>> You too must be a brain dead moron, I have explained this hundreds of
>> times.
>
> You are the brain dead moron: it PREDICTS a WRONG outcome because Px
> should always halt, the only reason Px is not halting is because your
> so-called halt decider isn't designed properly.
>
> /Flibble
>


Click here to read the complete article
Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon is just a Troll ]

<F6sOK.841862$J0r9.210570@fx11.iad>

  copy mid

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

  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.13.0
Subject: Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon
is just a Troll ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<JW-dnR36cO3PYJX-nZ2dnZfqlJ_NnZ2d@giganews.com>
<bm7OK.161341$f81.105014@fx43.iad>
<Q8CdnevelfQlkZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<GW8OK.779719$5fVf.536789@fx09.iad>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 722
Message-ID: <F6sOK.841862$J0r9.210570@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, 27 Aug 2022 13:02:29 -0400
X-Received-Bytes: 37363
 by: Richard Damon - Sat, 27 Aug 2022 17:02 UTC

On 8/27/22 12:55 PM, olcott wrote:
> On 8/27/2022 10:42 AM, Richard Damon wrote:
>> On 8/27/22 11:25 AM, olcott wrote:
>>> On 8/27/2022 10:11 AM, Richard Damon wrote:
>>>> On 8/27/22 11:03 AM, olcott wrote:
>>>>> On 8/27/2022 9:56 AM, Richard Damon wrote:
>>>>>> On 8/27/22 10:48 AM, olcott wrote:
>>>>>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>
>>>>>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34 PM
>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 3:43:46 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 11:59:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at 6:08:25 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the execution
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches line-by-line
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of this input never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reaches its final state and stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running: (a) H(P,P) simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (d) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0((u32)Infinite_Loop)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider must
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches a correct non-terminating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly match a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behaviour. The
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly report
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly report
>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
>>>>>>>>>>>>>>>>>>>>>>>>>>> entirely
>>>>>>>>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its actual
>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P, P) is P
>>>>>>>>>>>>>>>>>>>>>>>>>> and so H must report on what P does. The second
>>>>>>>>>>>>>>>>>>>>>>>>>> argument is also P and so specifically H must
>>>>>>>>>>>>>>>>>>>>>>>>>> report on what P(P) does. The idea that H(P,
>>>>>>>>>>>>>>>>>>>>>>>>>> P) has
>>>>>>>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> description always
>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by this
>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls
>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it into
>>>>>>>>>>>>>>>>>>>>>>>>>> asterisks doesn't make it true. I've told you
>>>>>>>>>>>>>>>>>>>>>>>>>> twice
>>>>>>>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown by
>>>>>>>>>>>>>>>>>>>>>>>>> replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will do
>>>>>>>>>>>>>>>>>>>>>>>>>> simply
>>>>>>>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would do and
>>>>>>>>>>>>>>>>>>>>>>>>>> pretending a different H will do the same thing.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK OUT
>>>>>>>>>>>>>>>>>>>>>>>>> WHAT A
>>>>>>>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what they are
>>>>>>>>>>>>>>>>>>>>>>>>> supposed to do and that is how they work.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT would
>>>>>>>>>>>>>>>>>>>>>>>> do, AS
>>>>>>>>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your SHDs
>>>>>>>>>>>>>>>>>>>>>>>> aren't
>>>>>>>>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>      > On Monday, July 25, 2022 at 12:10:34 AM
>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>      > olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>      >> If a simulating halt decider continues to
>>>>>>>>>>>>>>>>>>>>>>>>>      >> correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>>>>>      >> correctly matches a non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>      >> pattern then this SHD is necessarily
>>>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>>>>      >> when it aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>>>>>>      >> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>      >
>>>>>>>>>>>>>>>>>>>>>>>>>      > Yes, *If* a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>> continues
>>>>>>>>>>>>>>>>>>>>>>>>>      > to correctly simulate its input until it
>>>>>>>>>>>>>>>>>>>>>>>>>      > *correctly* matches a non- halting
>>>>>>>>>>>>>>>>>>>>>>>>> behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>      > pattern then this SHD is correct when it
>>>>>>>>>>>>>>>>>>>>>>>>>      > aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>      > [*some content snipped to stay focused
>>>>>>>>>>>>>>>>>>>>>>>>> on this
>>>>>>>>>>>>>>>>>>>>>>>>>      > point*]
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior of its
>>>>>>>>>>>>>>>>>>>>>>>>> input if H0 never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of H0 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>> of its input if H never aborted the simulation
>>>>>>>>>>>>>>>>>>>>>>>>> of its
>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The fact that
>>>>>>>>>>>>>>>>>>>>>>>> the correct answer doesn't actually depend on the
>>>>>>>>>>>>>>>>>>>>>>>> behavior of H1 say you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>        Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input if H
>>>>>>>>>>>>>>>>>>>>>>>>> never aborted the simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would do it H
>>>>>>>>>>>>>>>>>>>>>>>> never aborted it, since H does abort it, so you are
>>>>>>>>>>>>>>>>>>>>>>>> asking a question that is a fantasy.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If H
>>>>>>>>>>>>>>>>>>>>>>>>>>>> recognises that it is stuck in a loop and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> stops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence
>>>>>>>>>>>>>>>>>>>>>>>>>>>> ploughs
>>>>>>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final state of
>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many times you
>>>>>>>>>>>>>>>>>>>>>>>>>> must realise you're pulling a fast one here. You
>>>>>>>>>>>>>>>>>>>>>>>>>> claim that P(P) halts. However, you are trying to
>>>>>>>>>>>>>>>>>>>>>>>>>> run an argument along the following lines:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to return
>>>>>>>>>>>>>>>>>>>>>>>> 1, but
>>>>>>>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x); // H is
>>>>>>>>>>>>>>>>>>>>>>>>> replaced with Simulate
>>>>>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the correct
>>>>>>>>>>>>>>>>>>>>>>>>>> answers.
>>>>>>>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation says P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>> does not halt. Therefore it is acceptable to say
>>>>>>>>>>>>>>>>>>>>>>>>>> that P(P) does not halt, and that H(P, P) = 0
>>>>>>>>>>>>>>>>>>>>>>>>>> is an
>>>>>>>>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give the
>>>>>>>>>>>>>>>>>>>>>>>> correct answer, or a correct simulation followed by
>>>>>>>>>>>>>>>>>>>>>>>> sound and valid logic will give the corret answer.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> gives different results from the directly
>>>>>>>>>>>>>>>>>>>>>>>>>> executed
>>>>>>>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that this
>>>>>>>>>>>>>>>>>>>>>>>>>> proves your simulator is incorrect, you feel
>>>>>>>>>>>>>>>>>>>>>>>>>> justified in rejecting the actual results
>>>>>>>>>>>>>>>>>>>>>>>>>> actually
>>>>>>>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your
>>>>>>>>>>>>>>>>>>>>>>>>>> "correct
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts, so
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it any
>>>>>>>>>>>>>>>>>>>>>>>> more
>>>>>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition that
>>>>>>>>>>>>>>>>>>>>>>> is set
>>>>>>>>>>>>>>>>>>>>>>> up because it is easier to defeat than an opponent's
>>>>>>>>>>>>>>>>>>>>>>> real argument.
>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so
>>>>>>>>>>>>>>>>>>>>>>> adept at
>>>>>>>>>>>>>>>>>>>>>>> using the strawman deception that gullible fools
>>>>>>>>>>>>>>>>>>>>>>> accept
>>>>>>>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as correct.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description always
>>>>>>>>>>>>>>>>>>>>>>> provides the
>>>>>>>>>>>>>>>>>>>>>>> actual behavior specified by this machine
>>>>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but H(P,P)
>>>>>>>>>>>>>>>>>>>>>> doesn't do.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>> performs a partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>> behavior of this partial simulation correctly
>>>>>>>>>>>>>>>>>>>>>>> matches a
>>>>>>>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the SHD
>>>>>>>>>>>>>>>>>>>>>>> halt
>>>>>>>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't
>>>>>>>>>>>>>>>>>>>>>> provided one
>>>>>>>>>>>>>>>>>>>>>> that you have actually proved is correct for this
>>>>>>>>>>>>>>>>>>>>>> case.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>> when-so-ever
>>>>>>>>>>>>>>>>>>>>>>> matching this behavior pattern proves that the
>>>>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD would
>>>>>>>>>>>>>>>>>>>>>>> never
>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and correct
>>>>>>>>>>>>>>>>>>>>>> simulation of thd input, that is an INVALID
>>>>>>>>>>>>>>>>>>>>>> definition.
>>>>>>>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a different
>>>>>>>>>>>>>>>>>>>>>> machine
>>>>>>>>>>>>>>>>>>>>>> if doing so changes the code at the input, which
>>>>>>>>>>>>>>>>>>>>>> includes ALL the code that P calls, not just the code
>>>>>>>>>>>>>>>>>>>>>> inside the "C function" of P.
>>>>>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its input
>>>>>>>>>>>>>>>>>>>>>>> would be if H was only a simulator and not a
>>>>>>>>>>>>>>>>>>>>>>> simulating halt decider. All simulating halt
>>>>>>>>>>>>>>>>>>>>>>> deciders
>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that would never
>>>>>>>>>>>>>>>>>>>>>>> otherwise halt. Here are three examples of that:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>> of its input, but only the behavior of some other
>>>>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on what the
>>>>>>>>>>>>>>>>>>>>> behavior of its input would be if the SHD performed a
>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
>>>>>>>>>>>>>>>>>>> supporting
>>>>>>>>>>>>>>>>>>> reasoning.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> YOU have quoted the soure of this before, but apparently
>>>>>>>>>>>>>>>>>> your mind can't actually reason or remember.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>>>>>>> A halt decider must always derive its halt status
>>>>>>>>>>>>>>>>>>> decision
>>>>>>>>>>>>>>>>>>> on the basis of the actual behavior of the actual input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior" of the
>>>>>>>>>>>>>>>>>> "actual input" for an x86 decider is what happens when
>>>>>>>>>>>>>>>>>> you
>>>>>>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is the
>>>>>>>>>>>>>>>>>> actual behavor of running P(P)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and complete
>>>>>>>>>>>>>>>>>>> simulation of a machine description always provides the
>>>>>>>>>>>>>>>>>>> actual behavior specified by this machine description.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like P(d).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> This means that the actual behavior of the actual input
>>>>>>>>>>>>>>>>>>> would be the correct and complete simulation of the
>>>>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>>>>> to H(P,P) at the exact same point in the execution trace
>>>>>>>>>>>>>>>>>>> where H is invoked:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as that
>>>>>>>>>>>>>>>>>> point is actually a call to H, and is looking for the
>>>>>>>>>>>>>>>>>> Behavior or H which is supposed to be asking about the
>>>>>>>>>>>>>>>>>> behavior of it input, which is the SEPERATE PROGRA P(P),
>>>>>>>>>>>>>>>>>> not as executed "At that point in the execution
>>>>>>>>>>>>>>>>>> trace", but
>>>>>>>>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don;t think you know enough about how a program
>>>>>>>>>>>>>>>>>> works to
>>>>>>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>> The actual behavior of the actual input is defined as the
>>>>>>>>>>>>>>>>> behavior of the correct and complete simulation of this
>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>>>>>>>>> corresponded to that behavior, and it whated that in finite
>>>>>>>>>>>>>>>> time.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, replacing the call to H with a simulation of the
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is the job of H to correctly predict what the
>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>> its input would be if H performed a correct and complete
>>>>>>>>>>>>>>>>> simulation of this input:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, it is to correct predict what the behavior of its
>>>>>>>>>>>>>>>> input
>>>>>>>>>>>>>>>> would be if given to a correct and complete simulation
>>>>>>>>>>>>>>>> of this
>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation of its
>>>>>>>>>>>>>>>> input, you statement is nonsence.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Recursion
>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But doesn't do a correct and complete simulation of its
>>>>>>>>>>>>>>>> input,
>>>>>>>>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE BEEN
>>>>>>>>>>>>>>> REPEATED
>>>>>>>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT HAVE
>>>>>>>>>>>>>>> ACTUAL
>>>>>>>>>>>>>>> BRAIN DAMAGE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>> what the behavior of its input would be if H performed a
>>>>>>>>>>>>>>> correct and complete simulation of this input:
>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>> (b) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>> (c) that simulates P(P) that calls a simulated H(P,P)
>>>>>>>>>>>>>>> (d) that simulates P(P) that calls a simulated H(P,P)... (on
>>>>>>>>>>>>>>> and on)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You've told us numerous times that H does not do this -
>>>>>>>>>>>>>> you have
>>>>>>>>>>>>>> even explained why it does not do this. So H is not
>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>> itself correctly.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I could have equally been told many times that cats are a
>>>>>>>>>>>>> kind of
>>>>>>>>>>>>> dog, that does not make it true.
>>>>>>>>>>>>>
>>>>>>>>>>>>> A simulating halt decider always predicts what the behavior of
>>>>>>>>>>>>> its input would be if a correct and complete simulation of
>>>>>>>>>>>>> this
>>>>>>>>>>>>> input was performed at the exact same place in the execution
>>>>>>>>>>>>> trace where H is invoked.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>> {
>>>>>>>>>>>>>       int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>       if (Halt_Status)
>>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>>>       return;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on and
>>>>>>>>>>>>> on)
>>>>>>>>>>>>
>>>>>>>>>>>> But the fact your H is recursive in nature PREVENTS it from
>>>>>>>>>>>> performing a "correct and complete simulation of this
>>>>>>>>>>>> input".  H
>>>>>>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>>>>>>
>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>> {
>>>>>>>>>>>>      (void)H(x, x);
>>>>>>>>>>>>      return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> Flibble does not even know enough to know that when H(Px,Px)
>>>>>>>>>>> correctly simulates its input that the "return" instruction is
>>>>>>>>>>> unreachable code by this simulated input.
>>>>>>>>>>
>>>>>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT to do
>>>>>>>>>> that as a halt decider is supposed to return a decision to its
>>>>>>>>>> caller (Px in this case).
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> In none of these cases will the simulated P(P) ever reach its own
>>>>>>>>> final state:
>>>>>>>>>
>>>>>>>>> void Px(u32 x)
>>>>>>>>> {
>>>>>>>>>      H(x, x);
>>>>>>>>>      return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void Py(u32 x)
>>>>>>>>> {
>>>>>>>>>      Simulate(x, x);
>>>>>>>>>      return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> void Pz(u32 x)
>>>>>>>>> {
>>>>>>>>>      UTM(x, x);
>>>>>>>>>      return;
>>>>>>>>> }
>>>>>>>>
>>>>>>>> Error by non-equivalence: a halt decider (i.e. H) is supposed to
>>>>>>>> return
>>>>>>>> a result to its caller in finite time.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> The outermost H returns to its caller, the first inner H is
>>>>>>> aborted before it is even invoked.
>>>>>>>
>>>>>>
>>>>>> Which mean that an ACTUAL SIMULATION of the  actual input to
>>>>>> H(Px,Px), which would be shown by Simulate(Px,Px) or UTM(Px, Px)
>>>>>> would Halt, and thus H is incorrect.
>>>>>>
>>>>>
>>>>> No you brain dead moron and aborted process is not a process that
>>>>> halts.
>>>>> No simulated Px ever reaches its own "return" instruction.
>>>>
>>>> WRONG.
>>>>
>>>> Simulate(Px,Px) shows a simulated Px that reaches its return
>>>> instruction.
>>>>
>>> More of your God damned strawman deception. I say God damned because
>>> Revelations 21:8 indicates that Liars will be condemned to Hell by God.
>>> "God damned" literally means condemned to Hell by God.
>>>
>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return" INSTRUCTION.
>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return" INSTRUCTION.
>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return" INSTRUCTION.
>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return" INSTRUCTION.
>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return" INSTRUCTION.
>>>
>>
>> So?
>>
>> No H that gives an answer does a complete simulation, so it doesn't
>> show the answer to the question.
>>
>> You are just eating your POOP.
>>
>> The Halting Problem is about the behavior of the machine given to the
>> decider, or the complete (and correct) simulation of the input.
>>
>> H is wrong about that, and you have wasted the last 18 years of your
>> life eating POOP and thinking you were doing something.
>>
>> Your Legacy is of a Pathological Lying Idiot.
>>
>> Bye-Bye.
>
>


Click here to read the complete article
Re: Olcott [Paul N does care about facts and truth ] [ Richard Damon is just a Troll ]

<20220827180455.00006e13@reddwarf.jmc.corp>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder8.news.weretis.net!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx02.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Olcott [Paul N does care about facts and truth ] [ Richard
Damon is just a Troll ]
Message-ID: <20220827180455.00006e13@reddwarf.jmc.corp>
References: <20220817174635.00004410@reddwarf.jmc.corp>
<Q8CdnevelfQlkZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<GW8OK.779719$5fVf.536789@fx09.iad>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Lines: 761
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 27 Aug 2022 17:04:55 UTC
Date: Sat, 27 Aug 2022 18:04:55 +0100
X-Received-Bytes: 40182
 by: Mr Flibble - Sat, 27 Aug 2022 17:04 UTC

On Sat, 27 Aug 2022 13:02:29 -0400
Richard Damon <Richard@Damon-Family.org> wrote:

> On 8/27/22 12:55 PM, olcott wrote:
> > On 8/27/2022 10:42 AM, Richard Damon wrote:
> >> On 8/27/22 11:25 AM, olcott wrote:
> >>> On 8/27/2022 10:11 AM, Richard Damon wrote:
> >>>> On 8/27/22 11:03 AM, olcott wrote:
> >>>>> On 8/27/2022 9:56 AM, Richard Damon wrote:
> >>>>>> On 8/27/22 10:48 AM, olcott wrote:
> >>>>>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
> >>>>>>>> On Fri, 26 Aug 2022 19:13:09 -0500
> >>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>
> >>>>>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
> >>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
> >>>>>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
> >>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
> >>>>>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott
> >>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34
> >>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1,
> >>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:43:46 PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:59:25 PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:08:25 PM UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:50:37 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution trace of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> line-by-line the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never reaches its final
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state and stops running: (a)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) simulates P(P) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (c)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that simulates P(P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) that simulates P(P) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0((u32)Infinite_Loop)); }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual H.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behavior.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match a non-terminating behaviour.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behaviour of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subject is no rebuttal.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always provides the actual behavior
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> (SHD) correctly performs a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this partial
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> report non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> report that it doesn't.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
> >>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
> >>>>>>>>>>>>>>>>>>>>>>>>>>> entirely
> >>>>>>>>>>>>>>>>>>>>>>>>>>> different behavior
> >>>>>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its
> >>>>>>>>>>>>>>>>>>>>>>>>>>> actual input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P,
> >>>>>>>>>>>>>>>>>>>>>>>>>> P) is P and so H must report on what P
> >>>>>>>>>>>>>>>>>>>>>>>>>> does. The second argument is also P and so
> >>>>>>>>>>>>>>>>>>>>>>>>>> specifically H must report on what P(P)
> >>>>>>>>>>>>>>>>>>>>>>>>>> does. The idea that H(P, P) has
> >>>>>>>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is
> >>>>>>>>>>>>>>>>>>>>>>>>>> nonsense.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a
> >>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
> >>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
> >>>>>>>>>>>>>>>>>>>>>>>>>>> this machine description.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>> the input
> >>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
> >>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a
> >>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (c) that
> >>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls
> >>>>>>>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates
> >>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)...
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it
> >>>>>>>>>>>>>>>>>>>>>>>>>> into asterisks doesn't make it true. I've
> >>>>>>>>>>>>>>>>>>>>>>>>>> told you twice
> >>>>>>>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
> >>>>>>>>>>>>>>>>>>>>>>>>> complete
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown
> >>>>>>>>>>>>>>>>>>>>>>>>> by replacing H() with Simulate().
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>        return;
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> int main()
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will
> >>>>>>>>>>>>>>>>>>>>>>>>>> do simply
> >>>>>>>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would
> >>>>>>>>>>>>>>>>>>>>>>>>>> do and pretending a different H will do
> >>>>>>>>>>>>>>>>>>>>>>>>>> the same thing.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK
> >>>>>>>>>>>>>>>>>>>>>>>>> OUT WHAT A
> >>>>>>>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what
> >>>>>>>>>>>>>>>>>>>>>>>>> they are supposed to do and that is how
> >>>>>>>>>>>>>>>>>>>>>>>>> they work.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT
> >>>>>>>>>>>>>>>>>>>>>>>> would do, AS
> >>>>>>>>>>>>>>>>>>>>>>>> IS.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your
> >>>>>>>>>>>>>>>>>>>>>>>> SHDs aren't
> >>>>>>>>>>>>>>>>>>>>>>>> actually Halt Deciders.
> >>>>>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>      > On Monday, July 25, 2022 at 12:10:34
> >>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1,
> >>>>>>>>>>>>>>>>>>>>>>>>>      > olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>      >> If a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>> continues to >> correctly simulate its
> >>>>>>>>>>>>>>>>>>>>>>>>> input until it >> correctly matches a
> >>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior >> pattern then this
> >>>>>>>>>>>>>>>>>>>>>>>>> SHD is necessarily correct
> >>>>>>>>>>>>>>>>>>>>>>>>>      >> when it aborts its simulation and
> >>>>>>>>>>>>>>>>>>>>>>>>> reports >> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>      >
> >>>>>>>>>>>>>>>>>>>>>>>>>      > Yes, *If* a simulating halt decider
> >>>>>>>>>>>>>>>>>>>>>>>>> continues
> >>>>>>>>>>>>>>>>>>>>>>>>>      > to correctly simulate its input
> >>>>>>>>>>>>>>>>>>>>>>>>> until it > *correctly* matches a non-
> >>>>>>>>>>>>>>>>>>>>>>>>> halting behaviour
> >>>>>>>>>>>>>>>>>>>>>>>>>      > pattern then this SHD is correct
> >>>>>>>>>>>>>>>>>>>>>>>>> when it > aborts its simulation and reports
> >>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>      > [*some content snipped to stay
> >>>>>>>>>>>>>>>>>>>>>>>>> focused on this
> >>>>>>>>>>>>>>>>>>>>>>>>>      > point*]
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior
> >>>>>>>>>>>>>>>>>>>>>>>>> of its input if H0 never aborted the
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The
> >>>>>>>>>>>>>>>>>>>>>>>> fact that the correct answer doesn't
> >>>>>>>>>>>>>>>>>>>>>>>> actually depend on the behavior of H0 say
> >>>>>>>>>>>>>>>>>>>>>>>> you can "get away" with it.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
> >>>>>>>>>>>>>>>>>>>>>>>>> behavior
> >>>>>>>>>>>>>>>>>>>>>>>>> of its input if H never aborted the
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The
> >>>>>>>>>>>>>>>>>>>>>>>> fact that the correct answer doesn't
> >>>>>>>>>>>>>>>>>>>>>>>> actually depend on the behavior of H1 say
> >>>>>>>>>>>>>>>>>>>>>>>> you can "get away" with it.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>        Infinite_Recursion(N);
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input
> >>>>>>>>>>>>>>>>>>>>>>>>> if H never aborted the simulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would
> >>>>>>>>>>>>>>>>>>>>>>>> do it H never aborted it, since H does abort
> >>>>>>>>>>>>>>>>>>>>>>>> it, so you are asking a question that is a
> >>>>>>>>>>>>>>>>>>>>>>>> fantasy.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct when-so-ever matching this
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> H recognises that it is stuck in a loop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> and stops,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> ploughs
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> on regardless.
> >>>>>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the
> >>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final
> >>>>>>>>>>>>>>>>>>>>>>>>>>> state of this simulated input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many
> >>>>>>>>>>>>>>>>>>>>>>>>>> times you must realise you're pulling a
> >>>>>>>>>>>>>>>>>>>>>>>>>> fast one here. You claim that P(P) halts.
> >>>>>>>>>>>>>>>>>>>>>>>>>> However, you are trying to run an argument
> >>>>>>>>>>>>>>>>>>>>>>>>>> along the following lines:
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> A correct and
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
> >>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to
> >>>>>>>>>>>>>>>>>>>>>>>> return 1, but
> >>>>>>>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x); //
> >>>>>>>>>>>>>>>>>>>>>>>>> H is replaced with Simulate
> >>>>>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>>>>>>>        return;
> >>>>>>>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
> >>>>>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the
> >>>>>>>>>>>>>>>>>>>>>>>>>> correct answers.
> >>>>>>>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
> >>>>>>>>>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt,
> >>>>>>>>>>>>>>>>>>>>>>>>>> and that H(P, P) = 0 is an
> >>>>>>>>>>>>>>>>>>>>>>>>>> acceptable answer."
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give
> >>>>>>>>>>>>>>>>>>>>>>>> the correct answer, or a correct simulation
> >>>>>>>>>>>>>>>>>>>>>>>> followed by sound and valid logic will give
> >>>>>>>>>>>>>>>>>>>>>>>> the corret answer.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> H does neither of these.
> >>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulation
> >>>>>>>>>>>>>>>>>>>>>>>>>> gives different results from the directly
> >>>>>>>>>>>>>>>>>>>>>>>>>> executed
> >>>>>>>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that
> >>>>>>>>>>>>>>>>>>>>>>>>>> this proves your simulator is incorrect,
> >>>>>>>>>>>>>>>>>>>>>>>>>> you feel justified in rejecting the actual
> >>>>>>>>>>>>>>>>>>>>>>>>>> results actually
> >>>>>>>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your
> >>>>>>>>>>>>>>>>>>>>>>>>>> "correct
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulation".
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
> >>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts,
> >>>>>>>>>>>>>>>>>>>>>>>> so H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>> is wrong.
> >>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it
> >>>>>>>>>>>>>>>>>>>>>>>> any more
> >>>>>>>>>>>>>>>>>>>>>>>> right.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> *straw man*
> >>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
> >>>>>>>>>>>>>>>>>>>>>>> that is set
> >>>>>>>>>>>>>>>>>>>>>>> up because it is easier to defeat than an
> >>>>>>>>>>>>>>>>>>>>>>> opponent's real argument.
> >>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so
> >>>>>>>>>>>>>>>>>>>>>>> adept at
> >>>>>>>>>>>>>>>>>>>>>>> using the strawman deception that gullible
> >>>>>>>>>>>>>>>>>>>>>>> fools accept
> >>>>>>>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as
> >>>>>>>>>>>>>>>>>>>>>>> correct.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
> >>>>>>>>>>>>>>>>>>>>>>> complete simulation of a machine description
> >>>>>>>>>>>>>>>>>>>>>>> always provides the
> >>>>>>>>>>>>>>>>>>>>>>> actual behavior specified by this machine
> >>>>>>>>>>>>>>>>>>>>>>> description.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but
> >>>>>>>>>>>>>>>>>>>>>> H(P,P) doesn't do.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
> >>>>>>>>>>>>>>>>>>>>>>> correctly
> >>>>>>>>>>>>>>>>>>>>>>> performs a partial simulation of its input
> >>>>>>>>>>>>>>>>>>>>>>> and the behavior of this partial simulation
> >>>>>>>>>>>>>>>>>>>>>>> correctly matches a
> >>>>>>>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the
> >>>>>>>>>>>>>>>>>>>>>>> SHD halt
> >>>>>>>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't
> >>>>>>>>>>>>>>>>>>>>>> provided one
> >>>>>>>>>>>>>>>>>>>>>> that you have actually proved is correct for
> >>>>>>>>>>>>>>>>>>>>>> this case.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
> >>>>>>>>>>>>>>>>>>>>>>> when-so-ever
> >>>>>>>>>>>>>>>>>>>>>>> matching this behavior pattern proves that
> >>>>>>>>>>>>>>>>>>>>>>> the correct
> >>>>>>>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD
> >>>>>>>>>>>>>>>>>>>>>>> would never
> >>>>>>>>>>>>>>>>>>>>>>> reach the final state of this simulated
> >>>>>>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and
> >>>>>>>>>>>>>>>>>>>>>> correct simulation of thd input, that is an
> >>>>>>>>>>>>>>>>>>>>>> INVALID definition.
> >>>>>>>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a
> >>>>>>>>>>>>>>>>>>>>>> different machine
> >>>>>>>>>>>>>>>>>>>>>> if doing so changes the code at the input,
> >>>>>>>>>>>>>>>>>>>>>> which includes ALL the code that P calls, not
> >>>>>>>>>>>>>>>>>>>>>> just the code inside the "C function" of P.
> >>>>>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its
> >>>>>>>>>>>>>>>>>>>>>>> input would be if H was only a simulator and
> >>>>>>>>>>>>>>>>>>>>>>> not a simulating halt decider. All simulating
> >>>>>>>>>>>>>>>>>>>>>>> halt deciders
> >>>>>>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that
> >>>>>>>>>>>>>>>>>>>>>>> would never otherwise halt. Here are three
> >>>>>>>>>>>>>>>>>>>>>>> examples of that:
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
> >>>>>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
> >>>>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
> >>>>>>>>>>>>>>>>>>>>>> (c) is WRONG.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
> >>>>>>>>>>>>>>>>>>>>>> behavior
> >>>>>>>>>>>>>>>>>>>>>> of its input, but only the behavior of some
> >>>>>>>>>>>>>>>>>>>>>> other input
> >>>>>>>>>>>>>>>>>>>>>> built on a different H.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on
> >>>>>>>>>>>>>>>>>>>>> what the behavior of its input would be if the
> >>>>>>>>>>>>>>>>>>>>> SHD performed a correct and complete simulation
> >>>>>>>>>>>>>>>>>>>>> of its input.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Just by Definition.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> FAIL.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
> >>>>>>>>>>>>>>>>>>> supporting
> >>>>>>>>>>>>>>>>>>> reasoning.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
> >>>>>>>>>>>>>>>>>> understand
> >>>>>>>>>>>>>>>>>> because you are too stupid.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> YOU have quoted the soure of this before, but
> >>>>>>>>>>>>>>>>>> apparently your mind can't actually reason or
> >>>>>>>>>>>>>>>>>> remember.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
> >>>>>>>>>>>>>>>>>>> A halt decider must always derive its halt status
> >>>>>>>>>>>>>>>>>>> decision
> >>>>>>>>>>>>>>>>>>> on the basis of the actual behavior of the actual
> >>>>>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior"
> >>>>>>>>>>>>>>>>>> of the "actual input" for an x86 decider is what
> >>>>>>>>>>>>>>>>>> happens when you
> >>>>>>>>>>>>>>>>>> run that actual input.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is
> >>>>>>>>>>>>>>>>>> the actual behavor of running P(P)
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
> >>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
> >>>>>>>>>>>>>>>>>>> complete simulation of a machine description
> >>>>>>>>>>>>>>>>>>> always provides the actual behavior specified by
> >>>>>>>>>>>>>>>>>>> this machine description.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like
> >>>>>>>>>>>>>>>>>> P(d).
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> This means that the actual behavior of the actual
> >>>>>>>>>>>>>>>>>>> input would be the correct and complete
> >>>>>>>>>>>>>>>>>>> simulation of the input
> >>>>>>>>>>>>>>>>>>> to H(P,P) at the exact same point in the
> >>>>>>>>>>>>>>>>>>> execution trace where H is invoked:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as
> >>>>>>>>>>>>>>>>>> that point is actually a call to H, and is looking
> >>>>>>>>>>>>>>>>>> for the Behavior or H which is supposed to be
> >>>>>>>>>>>>>>>>>> asking about the behavior of it input, which is
> >>>>>>>>>>>>>>>>>> the SEPERATE PROGRA P(P), not as executed "At that
> >>>>>>>>>>>>>>>>>> point in the execution trace", but
> >>>>>>>>>>>>>>>>>> as an actual computation.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> I don;t think you know enough about how a program
> >>>>>>>>>>>>>>>>>> works to
> >>>>>>>>>>>>>>>>>> get into a beginners programming course.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>>>>>>> The actual behavior of the actual input is defined
> >>>>>>>>>>>>>>>>> as the behavior of the correct and complete
> >>>>>>>>>>>>>>>>> simulation of this input.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
> >>>>>>>>>>>>>>>> simulation
> >>>>>>>>>>>>>>>> of the input to H, it wanted a halting decision that
> >>>>>>>>>>>>>>>> corresponded to that behavior, and it whated that in
> >>>>>>>>>>>>>>>> finite time.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Thus, replacing the call to H with a simulation of
> >>>>>>>>>>>>>>>> the input
> >>>>>>>>>>>>>>>> to H is not a correct substitution.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> It is the job of H to correctly predict what the
> >>>>>>>>>>>>>>>>> behavior of
> >>>>>>>>>>>>>>>>> its input would be if H performed a correct and
> >>>>>>>>>>>>>>>>> complete simulation of this input:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Nope, it is to correct predict what the behavior of
> >>>>>>>>>>>>>>>> its input
> >>>>>>>>>>>>>>>> would be if given to a correct and complete
> >>>>>>>>>>>>>>>> simulation of this
> >>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation
> >>>>>>>>>>>>>>>> of its input, you statement is nonsence.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
> >>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> // Never reaches the final state of
> >>>>>>>>>>>>>>>>> Infinite_Recursion (b) H(Infinite_Recursion, 0x777)
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> // Never reaches the final state of P
> >>>>>>>>>>>>>>>>> (c) H(P,P)
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> But doesn't do a correct and complete simulation of
> >>>>>>>>>>>>>>>> its input,
> >>>>>>>>>>>>>>>> so it didn't establish the needed criteria.
> >>>>>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE
> >>>>>>>>>>>>>>> BEEN REPEATED
> >>>>>>>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
> >>>>>>>>>>>>>>> HAVE ACTUAL
> >>>>>>>>>>>>>>> BRAIN DAMAGE.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> It is the job of H to correctly:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> PREDICT
> >>>>>>>>>>>>>>> what the behavior of its input would be if H
> >>>>>>>>>>>>>>> performed a correct and complete simulation of this
> >>>>>>>>>>>>>>> input: (a) H(P,P) simulates P(P) that calls a
> >>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P) that calls a
> >>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls a
> >>>>>>>>>>>>>>> simulated H(P,P) (d) that simulates P(P) that calls a
> >>>>>>>>>>>>>>> simulated H(P,P)... (on and on)
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You've told us numerous times that H does not do this
> >>>>>>>>>>>>>> - you have
> >>>>>>>>>>>>>> even explained why it does not do this. So H is not
> >>>>>>>>>>>>>> simulating
> >>>>>>>>>>>>>> itself correctly.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> I could have equally been told many times that cats are
> >>>>>>>>>>>>> a kind of
> >>>>>>>>>>>>> dog, that does not make it true.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> A simulating halt decider always predicts what the
> >>>>>>>>>>>>> behavior of its input would be if a correct and
> >>>>>>>>>>>>> complete simulation of this
> >>>>>>>>>>>>> input was performed at the exact same place in the
> >>>>>>>>>>>>> execution trace where H is invoked.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>> {
> >>>>>>>>>>>>>       int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>>>       if (Halt_Status)
> >>>>>>>>>>>>>         HERE: goto HERE;
> >>>>>>>>>>>>>       return;
> >>>>>>>>>>>>> }
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
> >>>>>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
> >>>>>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
> >>>>>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on
> >>>>>>>>>>>>> and on)
> >>>>>>>>>>>>
> >>>>>>>>>>>> But the fact your H is recursive in nature PREVENTS it
> >>>>>>>>>>>> from performing a "correct and complete simulation of
> >>>>>>>>>>>> this input".  H
> >>>>>>>>>>>> deciding the following is non-halting is an ERROR:
> >>>>>>>>>>>>
> >>>>>>>>>>>> void Px(ptr x)
> >>>>>>>>>>>> {
> >>>>>>>>>>>>      (void)H(x, x);
> >>>>>>>>>>>>      return;
> >>>>>>>>>>>> }
> >>>>>>>>>>>>
> >>>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>> Flibble does not even know enough to know that when
> >>>>>>>>>>> H(Px,Px) correctly simulates its input that the "return"
> >>>>>>>>>>> instruction is unreachable code by this simulated input.
> >>>>>>>>>>
> >>>>>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT
> >>>>>>>>>> to do that as a halt decider is supposed to return a
> >>>>>>>>>> decision to its caller (Px in this case).
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>> In none of these cases will the simulated P(P) ever reach
> >>>>>>>>> its own final state:
> >>>>>>>>>
> >>>>>>>>> void Px(u32 x)
> >>>>>>>>> {
> >>>>>>>>>      H(x, x);
> >>>>>>>>>      return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> void Py(u32 x)
> >>>>>>>>> {
> >>>>>>>>>      Simulate(x, x);
> >>>>>>>>>      return;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> void Pz(u32 x)
> >>>>>>>>> {
> >>>>>>>>>      UTM(x, x);
> >>>>>>>>>      return;
> >>>>>>>>> }
> >>>>>>>>
> >>>>>>>> Error by non-equivalence: a halt decider (i.e. H) is
> >>>>>>>> supposed to return
> >>>>>>>> a result to its caller in finite time.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>>
> >>>>>>>
> >>>>>>> The outermost H returns to its caller, the first inner H is
> >>>>>>> aborted before it is even invoked.
> >>>>>>>
> >>>>>>
> >>>>>> Which mean that an ACTUAL SIMULATION of the  actual input to
> >>>>>> H(Px,Px), which would be shown by Simulate(Px,Px) or UTM(Px,
> >>>>>> Px) would Halt, and thus H is incorrect.
> >>>>>>
> >>>>>
> >>>>> No you brain dead moron and aborted process is not a process
> >>>>> that halts.
> >>>>> No simulated Px ever reaches its own "return" instruction.
> >>>>
> >>>> WRONG.
> >>>>
> >>>> Simulate(Px,Px) shows a simulated Px that reaches its return
> >>>> instruction.
> >>>>
> >>> More of your God damned strawman deception. I say God damned
> >>> because Revelations 21:8 indicates that Liars will be condemned
> >>> to Hell by God. "God damned" literally means condemned to Hell by
> >>> God.
> >>>
> >>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return"
> >>> INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN
> >>> "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER REACHES
> >>> IT OWN "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER
> >>> REACHES IT OWN "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H
> >>> EVER REACHES IT OWN "return" INSTRUCTION.
> >>
> >> So?
> >>
> >> No H that gives an answer does a complete simulation, so it
> >> doesn't show the answer to the question.
> >>
> >> You are just eating your POOP.
> >>
> >> The Halting Problem is about the behavior of the machine given to
> >> the decider, or the complete (and correct) simulation of the input.
> >>
> >> H is wrong about that, and you have wasted the last 18 years of
> >> your life eating POOP and thinking you were doing something.
> >>
> >> Your Legacy is of a Pathological Lying Idiot.
> >>
> >> Bye-Bye.
> >
> >
>
> Cat got your tongue?
>
> Or just caught wordless because you are seeing you have no answer?


Click here to read the complete article
Re: Peter Olcott is a Clueless Pathological Lying Troll

<_usOK.169547$nZ1.79892@fx05.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx05.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.13.0
Subject: Re: Peter Olcott is a Clueless Pathological Lying Troll
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<Q8CdnevelfQlkZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<GW8OK.779719$5fVf.536789@fx09.iad>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <20220827180455.00006e13@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 762
Message-ID: <_usOK.169547$nZ1.79892@fx05.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, 27 Aug 2022 13:28:25 -0400
X-Received-Bytes: 39840
 by: Richard Damon - Sat, 27 Aug 2022 17:28 UTC

On 8/27/22 1:04 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 13:02:29 -0400
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 8/27/22 12:55 PM, olcott wrote:
>>> On 8/27/2022 10:42 AM, Richard Damon wrote:
>>>> On 8/27/22 11:25 AM, olcott wrote:
>>>>> On 8/27/2022 10:11 AM, Richard Damon wrote:
>>>>>> On 8/27/22 11:03 AM, olcott wrote:
>>>>>>> On 8/27/2022 9:56 AM, Richard Damon wrote:
>>>>>>>> On 8/27/22 10:48 AM, olcott wrote:
>>>>>>>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott
>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34
>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:43:46 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:59:25 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:08:25 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never reaches its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state and stops running: (a)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (c)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0((u32)Infinite_Loop)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match a non-terminating behaviour.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always provides the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (SHD) correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> entirely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> P) is P and so H must report on what P
>>>>>>>>>>>>>>>>>>>>>>>>>>>> does. The second argument is also P and so
>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifically H must report on what P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> does. The idea that H(P, P) has
>>>>>>>>>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (c) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it
>>>>>>>>>>>>>>>>>>>>>>>>>>>> into asterisks doesn't make it true. I've
>>>>>>>>>>>>>>>>>>>>>>>>>>>> told you twice
>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown
>>>>>>>>>>>>>>>>>>>>>>>>>>> by replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>        Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>> do simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would
>>>>>>>>>>>>>>>>>>>>>>>>>>>> do and pretending a different H will do
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same thing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK
>>>>>>>>>>>>>>>>>>>>>>>>>>> OUT WHAT A
>>>>>>>>>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what
>>>>>>>>>>>>>>>>>>>>>>>>>>> they are supposed to do and that is how
>>>>>>>>>>>>>>>>>>>>>>>>>>> they work.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>> would do, AS
>>>>>>>>>>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your
>>>>>>>>>>>>>>>>>>>>>>>>>> SHDs aren't
>>>>>>>>>>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > On Monday, July 25, 2022 at 12:10:34
>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>      >> If a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>> continues to >> correctly simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input until it >> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior >> pattern then this
>>>>>>>>>>>>>>>>>>>>>>>>>>> SHD is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>      >> when it aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>> reports >> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>      >
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > Yes, *If* a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>> continues
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > to correctly simulate its input
>>>>>>>>>>>>>>>>>>>>>>>>>>> until it > *correctly* matches a non-
>>>>>>>>>>>>>>>>>>>>>>>>>>> halting behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > pattern then this SHD is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>> when it > aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > [*some content snipped to stay
>>>>>>>>>>>>>>>>>>>>>>>>>>> focused on this
>>>>>>>>>>>>>>>>>>>>>>>>>>>      > point*]
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input if H0 never aborted the
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The
>>>>>>>>>>>>>>>>>>>>>>>>>> fact that the correct answer doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>> actually depend on the behavior of H0 say
>>>>>>>>>>>>>>>>>>>>>>>>>> you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>        HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input if H never aborted the
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The
>>>>>>>>>>>>>>>>>>>>>>>>>> fact that the correct answer doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>> actually depend on the behavior of H1 say
>>>>>>>>>>>>>>>>>>>>>>>>>> you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>        Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>> if H never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would
>>>>>>>>>>>>>>>>>>>>>>>>>> do it H never aborted it, since H does abort
>>>>>>>>>>>>>>>>>>>>>>>>>> it, so you are asking a question that is a
>>>>>>>>>>>>>>>>>>>>>>>>>> fantasy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H recognises that it is stuck in a loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and stops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ploughs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many
>>>>>>>>>>>>>>>>>>>>>>>>>>>> times you must realise you're pulling a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> fast one here. You claim that P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> However, you are trying to run an argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>> along the following lines:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to
>>>>>>>>>>>>>>>>>>>>>>>>>> return 1, but
>>>>>>>>>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x); //
>>>>>>>>>>>>>>>>>>>>>>>>>>> H is replaced with Simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answers.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> and that H(P, P) = 0 is an
>>>>>>>>>>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give
>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer, or a correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> followed by sound and valid logic will give
>>>>>>>>>>>>>>>>>>>>>>>>>> the corret answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>> gives different results from the directly
>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed
>>>>>>>>>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this proves your simulator is incorrect,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you feel justified in rejecting the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>> results actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts,
>>>>>>>>>>>>>>>>>>>>>>>>>> so H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>> any more
>>>>>>>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
>>>>>>>>>>>>>>>>>>>>>>>>> that is set
>>>>>>>>>>>>>>>>>>>>>>>>> up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so
>>>>>>>>>>>>>>>>>>>>>>>>> adept at
>>>>>>>>>>>>>>>>>>>>>>>>> using the strawman deception that gullible
>>>>>>>>>>>>>>>>>>>>>>>>> fools accept
>>>>>>>>>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as
>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>> always provides the
>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior specified by this machine
>>>>>>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) doesn't do.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>> performs a partial simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>> and the behavior of this partial simulation
>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the
>>>>>>>>>>>>>>>>>>>>>>>>> SHD halt
>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't
>>>>>>>>>>>>>>>>>>>>>>>> provided one
>>>>>>>>>>>>>>>>>>>>>>>> that you have actually proved is correct for
>>>>>>>>>>>>>>>>>>>>>>>> this case.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever
>>>>>>>>>>>>>>>>>>>>>>>>> matching this behavior pattern proves that
>>>>>>>>>>>>>>>>>>>>>>>>> the correct
>>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD
>>>>>>>>>>>>>>>>>>>>>>>>> would never
>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this simulated
>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and
>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of thd input, that is an
>>>>>>>>>>>>>>>>>>>>>>>> INVALID definition.
>>>>>>>>>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a
>>>>>>>>>>>>>>>>>>>>>>>> different machine
>>>>>>>>>>>>>>>>>>>>>>>> if doing so changes the code at the input,
>>>>>>>>>>>>>>>>>>>>>>>> which includes ALL the code that P calls, not
>>>>>>>>>>>>>>>>>>>>>>>> just the code inside the "C function" of P.
>>>>>>>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its
>>>>>>>>>>>>>>>>>>>>>>>>> input would be if H was only a simulator and
>>>>>>>>>>>>>>>>>>>>>>>>> not a simulating halt decider. All simulating
>>>>>>>>>>>>>>>>>>>>>>>>> halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that
>>>>>>>>>>>>>>>>>>>>>>>>> would never otherwise halt. Here are three
>>>>>>>>>>>>>>>>>>>>>>>>> examples of that:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>> of its input, but only the behavior of some
>>>>>>>>>>>>>>>>>>>>>>>> other input
>>>>>>>>>>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on
>>>>>>>>>>>>>>>>>>>>>>> what the behavior of its input would be if the
>>>>>>>>>>>>>>>>>>>>>>> SHD performed a correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
>>>>>>>>>>>>>>>>>>>>> supporting
>>>>>>>>>>>>>>>>>>>>> reasoning.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
>>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> YOU have quoted the soure of this before, but
>>>>>>>>>>>>>>>>>>>> apparently your mind can't actually reason or
>>>>>>>>>>>>>>>>>>>> remember.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>>>>>>>>> A halt decider must always derive its halt status
>>>>>>>>>>>>>>>>>>>>> decision
>>>>>>>>>>>>>>>>>>>>> on the basis of the actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior"
>>>>>>>>>>>>>>>>>>>> of the "actual input" for an x86 decider is what
>>>>>>>>>>>>>>>>>>>> happens when you
>>>>>>>>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>> the actual behavor of running P(P)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
>>>>>>>>>>>>>>>>>>>>> complete simulation of a machine description
>>>>>>>>>>>>>>>>>>>>> always provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like
>>>>>>>>>>>>>>>>>>>> P(d).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> This means that the actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>> input would be the correct and complete
>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>> to H(P,P) at the exact same point in the
>>>>>>>>>>>>>>>>>>>>> execution trace where H is invoked:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as
>>>>>>>>>>>>>>>>>>>> that point is actually a call to H, and is looking
>>>>>>>>>>>>>>>>>>>> for the Behavior or H which is supposed to be
>>>>>>>>>>>>>>>>>>>> asking about the behavior of it input, which is
>>>>>>>>>>>>>>>>>>>> the SEPERATE PROGRA P(P), not as executed "At that
>>>>>>>>>>>>>>>>>>>> point in the execution trace", but
>>>>>>>>>>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I don;t think you know enough about how a program
>>>>>>>>>>>>>>>>>>>> works to
>>>>>>>>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>> The actual behavior of the actual input is defined
>>>>>>>>>>>>>>>>>>> as the behavior of the correct and complete
>>>>>>>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>>>>>>>>>>> corresponded to that behavior, and it whated that in
>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, replacing the call to H with a simulation of
>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is the job of H to correctly predict what the
>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>> its input would be if H performed a correct and
>>>>>>>>>>>>>>>>>>> complete simulation of this input:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, it is to correct predict what the behavior of
>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>> would be if given to a correct and complete
>>>>>>>>>>>>>>>>>> simulation of this
>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation
>>>>>>>>>>>>>>>>>> of its input, you statement is nonsence.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Never reaches the final state of
>>>>>>>>>>>>>>>>>>> Infinite_Recursion (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But doesn't do a correct and complete simulation of
>>>>>>>>>>>>>>>>>> its input,
>>>>>>>>>>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE
>>>>>>>>>>>>>>>>> BEEN REPEATED
>>>>>>>>>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
>>>>>>>>>>>>>>>>> HAVE ACTUAL
>>>>>>>>>>>>>>>>> BRAIN DAMAGE.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>> what the behavior of its input would be if H
>>>>>>>>>>>>>>>>> performed a correct and complete simulation of this
>>>>>>>>>>>>>>>>> input: (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P) (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>> simulated H(P,P)... (on and on)
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You've told us numerous times that H does not do this
>>>>>>>>>>>>>>>> - you have
>>>>>>>>>>>>>>>> even explained why it does not do this. So H is not
>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>> itself correctly.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I could have equally been told many times that cats are
>>>>>>>>>>>>>>> a kind of
>>>>>>>>>>>>>>> dog, that does not make it true.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> A simulating halt decider always predicts what the
>>>>>>>>>>>>>>> behavior of its input would be if a correct and
>>>>>>>>>>>>>>> complete simulation of this
>>>>>>>>>>>>>>> input was performed at the exact same place in the
>>>>>>>>>>>>>>> execution trace where H is invoked.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>       int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>       if (Halt_Status)
>>>>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>>>>>       return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on
>>>>>>>>>>>>>>> and on)
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But the fact your H is recursive in nature PREVENTS it
>>>>>>>>>>>>>> from performing a "correct and complete simulation of
>>>>>>>>>>>>>> this input".  H
>>>>>>>>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>      (void)H(x, x);
>>>>>>>>>>>>>>      return;
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> Flibble does not even know enough to know that when
>>>>>>>>>>>>> H(Px,Px) correctly simulates its input that the "return"
>>>>>>>>>>>>> instruction is unreachable code by this simulated input.
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT
>>>>>>>>>>>> to do that as a halt decider is supposed to return a
>>>>>>>>>>>> decision to its caller (Px in this case).
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> In none of these cases will the simulated P(P) ever reach
>>>>>>>>>>> its own final state:
>>>>>>>>>>>
>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>      H(x, x);
>>>>>>>>>>>      return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> void Py(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>      Simulate(x, x);
>>>>>>>>>>>      return;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> void Pz(u32 x)
>>>>>>>>>>> {
>>>>>>>>>>>      UTM(x, x);
>>>>>>>>>>>      return;
>>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Error by non-equivalence: a halt decider (i.e. H) is
>>>>>>>>>> supposed to return
>>>>>>>>>> a result to its caller in finite time.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> The outermost H returns to its caller, the first inner H is
>>>>>>>>> aborted before it is even invoked.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which mean that an ACTUAL SIMULATION of the  actual input to
>>>>>>>> H(Px,Px), which would be shown by Simulate(Px,Px) or UTM(Px,
>>>>>>>> Px) would Halt, and thus H is incorrect.
>>>>>>>>
>>>>>>>
>>>>>>> No you brain dead moron and aborted process is not a process
>>>>>>> that halts.
>>>>>>> No simulated Px ever reaches its own "return" instruction.
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>> Simulate(Px,Px) shows a simulated Px that reaches its return
>>>>>> instruction.
>>>>>>
>>>>> More of your God damned strawman deception. I say God damned
>>>>> because Revelations 21:8 indicates that Liars will be condemned
>>>>> to Hell by God. "God damned" literally means condemned to Hell by
>>>>> God.
>>>>>
>>>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return"
>>>>> INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN
>>>>> "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER REACHES
>>>>> IT OWN "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER
>>>>> REACHES IT OWN "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H
>>>>> EVER REACHES IT OWN "return" INSTRUCTION.
>>>>
>>>> So?
>>>>
>>>> No H that gives an answer does a complete simulation, so it
>>>> doesn't show the answer to the question.
>>>>
>>>> You are just eating your POOP.
>>>>
>>>> The Halting Problem is about the behavior of the machine given to
>>>> the decider, or the complete (and correct) simulation of the input.
>>>>
>>>> H is wrong about that, and you have wasted the last 18 years of
>>>> your life eating POOP and thinking you were doing something.
>>>>
>>>> Your Legacy is of a Pathological Lying Idiot.
>>>>
>>>> Bye-Bye.
>>>
>>>
>>
>> Cat got your tongue?
>>
>> Or just caught wordless because you are seeing you have no answer?
>
> He is just replying to change the subject line to call you a troll and
> to say that I am clueless about software engineering. He really is a
> fucktard who has got nothing of value to contribute.
>
> /Flibble
>


Click here to read the complete article
Olcott Ignores Trolls

<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 17:32:23 +0000
Date: Sat, 27 Aug 2022 12:32:22 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Olcott Ignores Trolls
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<GW8OK.779719$5fVf.536789@fx09.iad>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <_usOK.169547$nZ1.79892@fx05.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 759
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-nmv+u9mcRGpSobtDdS3cWibTlVa+BLESRYOFkcG2HIURNQzMQW65H34Wd8l53zQlWHB1/BO7euztfGd!/wD8rrkpen52NXNHvtk9dXx2WXxuzIj8ebtJjJbWgi6H2QDxXnTQ5nkm99RYMXO7UlSvyMbA5rY=
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
 by: olcott - Sat, 27 Aug 2022 17:32 UTC

On 8/27/2022 12:28 PM, Richard Damon wrote:
>
> On 8/27/22 1:04 PM, Mr Flibble wrote:
>> On Sat, 27 Aug 2022 13:02:29 -0400
>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>> On 8/27/22 12:55 PM, olcott wrote:
>>>> On 8/27/2022 10:42 AM, Richard Damon wrote:
>>>>> On 8/27/22 11:25 AM, olcott wrote:
>>>>>> On 8/27/2022 10:11 AM, Richard Damon wrote:
>>>>>>> On 8/27/22 11:03 AM, olcott wrote:
>>>>>>>> On 8/27/2022 9:56 AM, Richard Damon wrote:
>>>>>>>>> On 8/27/22 10:48 AM, olcott wrote:
>>>>>>>>>> On 8/27/2022 6:08 AM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 26 Aug 2022 19:13:09 -0500
>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>> On 8/26/2022 6:49 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 26 Aug 2022 16:43:15 -0500
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>> On 8/26/2022 4:23 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Fri, 26 Aug 2022 16:06:19 -0500
>>>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
>>>>>>>>>>>>>>>> On 8/26/2022 3:29 PM, Paul N wrote:
>>>>>>>>>>>>>>>>> On Friday, August 26, 2022 at 9:24:47 PM UTC+1, olcott
>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>> On 8/26/2022 2:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 8/26/22 3:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 8/26/2022 2:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 8/26/22 2:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 12:25 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 1:05 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:45 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 11:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 10:02 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/22 10:47 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/26/2022 8:23 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 7:47:34
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 1:02 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at 6:12:10
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 12:00 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Wednesday, August 24, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:43:46 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/24/2022 6:10 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 11:59:25 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 5:47 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 6:08:25 PM UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/23/2022 11:35 AM, Paul N
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 23, 2022 at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 3:50:37 PM
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTC+1, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have proven that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> execution trace of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation of the input by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) exactly matches
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> line-by-line the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 source-code of P and this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> shows that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input never reaches its final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state and stops running: (a)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P) (c)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) that simulates P(P) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H does not always simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Output("Input_Halts = ",
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0((u32)Infinite_Loop)); }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *This is what would happen if H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always simulated its input*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So it's not what happens with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop) simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop() (b) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (c) goto HERE
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (d) goto HERE...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yet a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> must always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort the simulation of every
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It does this as soon as it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-terminating behavior.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But H(P, P) does not correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> match a non-terminating behaviour.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The behaviour of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) is that it terminates, or so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you claim.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Is an entirely different sequence of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instructions than the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation by H(P,P) of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> As you yourself have said, changing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the subject is no rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *Everyone also knows that*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) The correct and complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> always provides the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specified by this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but you admit that H does not do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (SHD) correctly performs a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of its input and the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of this partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation correctly matches a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the SHD halt decider can correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since P(P) halts, H can never correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> report that it doesn't.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is not reporting whether or not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main() { P(P); } halts because it has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> entirely
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> different behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> than the actual behavior specified by its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actual input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No it doesn't. The first argument of H(P,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P) is P and so H must report on what P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does. The second argument is also P and so
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> specifically H must report on what P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does. The idea that H(P, P) has
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> some sort of "input" which is not P is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> nonsense.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete simulation of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine description always
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The correct and complete simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) by H*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that calls a simulated H(P,P) (c) that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates P(P) that calls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a simulated H(P,P) (d) that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P) that calls a simulated H(P,P)...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You know this is not true, and putting it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> into asterisks doesn't make it true. I've
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> told you twice
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> in the quotes above alone.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is what the correct and COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) would do. A correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is shown
>>>>>>>>>>>>>>>>>>>>>>>>>>>> by replacing H() with Simulate().
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>           HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         Output("Input_Halts = ", H(P, P));
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't work out what an aborting H will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by working out what a non-aborting H would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do and pretending a different H will do
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the same thing.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider MUST ALWAYS WORK
>>>>>>>>>>>>>>>>>>>>>>>>>>>> OUT WHAT A
>>>>>>>>>>>>>>>>>>>>>>>>>>>> NON-ABORTING SHD WOULD DO. That is what
>>>>>>>>>>>>>>>>>>>>>>>>>>>> they are supposed to do and that is how
>>>>>>>>>>>>>>>>>>>>>>>>>>>> they work.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. It needs to work out what its INPUT
>>>>>>>>>>>>>>>>>>>>>>>>>>> would do, AS
>>>>>>>>>>>>>>>>>>>>>>>>>>> IS.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Otherwise you are just admitting that your
>>>>>>>>>>>>>>>>>>>>>>>>>>> SHDs aren't
>>>>>>>>>>>>>>>>>>>>>>>>>>> actually Halt Deciders.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 7/24/2022 6:19 PM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > On Monday, July 25, 2022 at 12:10:34
>>>>>>>>>>>>>>>>>>>>>>>>>>>> AM UTC+1,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       >> If a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>> continues to >> correctly simulate its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input until it >> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior >> pattern then this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SHD is necessarily correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       >> when it aborts its simulation and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reports >> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       >
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > Yes, *If* a simulating halt decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>> continues
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > to correctly simulate its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> until it > *correctly* matches a non-
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting behaviour
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > pattern then this SHD is correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>> when it > aborts its simulation and reports
>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > [*some content snipped to stay
>>>>>>>>>>>>>>>>>>>>>>>>>>>> focused on this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>       > point*]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H0(Infinite_Loop) reports on the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input if H0 never aborted the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The
>>>>>>>>>>>>>>>>>>>>>>>>>>> fact that the correct answer doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>> actually depend on the behavior of H0 say
>>>>>>>>>>>>>>>>>>>>>>>>>>> you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777) reports on the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input if H never aborted the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So? THat is still the wrong question. The
>>>>>>>>>>>>>>>>>>>>>>>>>>> fact that the correct answer doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>> actually depend on the behavior of H1 say
>>>>>>>>>>>>>>>>>>>>>>>>>>> you can "get away" with it.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void Infinite_Recursion(int N)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         Infinite_Recursion(N);
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) reports on the behavior of its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> if H never aborted the simulation of its
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No! The question isn't what its input would
>>>>>>>>>>>>>>>>>>>>>>>>>>> do it H never aborted it, since H does abort
>>>>>>>>>>>>>>>>>>>>>>>>>>> it, so you are asking a question that is a
>>>>>>>>>>>>>>>>>>>>>>>>>>> fantasy.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct when-so-ever matching this
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern proves that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input by SHD would never reach the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> final state of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is not simulating itself correctly. If
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H recognises that it is stuck in a loop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and stops,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is not correct to pretend that H never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> realises it is stuck in a loop and hence
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ploughs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on regardless.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H only must report on whether or not the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input would ever reach the final
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> state of this simulated input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You've talked about simulations so many
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> times you must realise you're pulling a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> fast one here. You claim that P(P) halts.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> However, you are trying to run an argument
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> along the following lines:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> A correct and
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> COMPLETE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of the input to H(P,P) is this
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Right, which H doesn't do but simulate does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Simulate(P,P) Halts, so H(P,P) needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>> return 1, but
>>>>>>>>>>>>>>>>>>>>>>>>>>> it incorrectly returns 0.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         int Halt_Status = Simulate(x, x); //
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is replaced with Simulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>           HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>>>>>>         return;
>>>>>>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> It SHOULD, but it doesn't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "A correct simulation will give the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct answers.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> My simulation is correct. My simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> says P(P) does not halt. Therefore it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> acceptable to say that P(P) does not halt,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and that H(P, P) = 0 is an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> acceptable answer."
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> A Correct AND COMPLETE simulation will give
>>>>>>>>>>>>>>>>>>>>>>>>>>> the correct answer, or a correct simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> followed by sound and valid logic will give
>>>>>>>>>>>>>>>>>>>>>>>>>>> the corret answer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> H does neither of these.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> At times you've explicitly said that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> gives different results from the directly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> executed
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function, but instead of recognising that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this proves your simulator is incorrect,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you feel justified in rejecting the actual
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> results actually
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> produced by the function in favour of your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> "correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation".
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H ALWAYS REPORTS ON THE BEHAVIOR OF PURE
>>>>>>>>>>>>>>>>>>>>>>>>>>>> SIMULATION
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> No, it doesn't, since Simulate(P,P) Halts,
>>>>>>>>>>>>>>>>>>>>>>>>>>> so H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>> is wrong.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Acting like a three year old doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>> any more
>>>>>>>>>>>>>>>>>>>>>>>>>>> right.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> *straw man*
>>>>>>>>>>>>>>>>>>>>>>>>>> An intentionally misrepresented proposition
>>>>>>>>>>>>>>>>>>>>>>>>>> that is set
>>>>>>>>>>>>>>>>>>>>>>>>>> up because it is easier to defeat than an
>>>>>>>>>>>>>>>>>>>>>>>>>> opponent's real argument.
>>>>>>>>>>>>>>>>>>>>>>>>>> https://www.lexico.com/en/definition/straw_man
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Please identify the "Strawman"
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are a despicable lying scumbag that is so
>>>>>>>>>>>>>>>>>>>>>>>>>> adept at
>>>>>>>>>>>>>>>>>>>>>>>>>> using the strawman deception that gullible
>>>>>>>>>>>>>>>>>>>>>>>>>> fools accept
>>>>>>>>>>>>>>>>>>>>>>>>>> your deceitful attempts at rebuttal as
>>>>>>>>>>>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>>>>>> always provides the
>>>>>>>>>>>>>>>>>>>>>>>>>> actual behavior specified by this machine
>>>>>>>>>>>>>>>>>>>>>>>>>> description.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right, which is what Simulate(P,P) does, but
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) doesn't do.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When-so-ever a simulating halt decider (SHD)
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> performs a partial simulation of its input
>>>>>>>>>>>>>>>>>>>>>>>>>> and the behavior of this partial simulation
>>>>>>>>>>>>>>>>>>>>>>>>>> correctly matches a
>>>>>>>>>>>>>>>>>>>>>>>>>> correct non-halting behavior pattern then the
>>>>>>>>>>>>>>>>>>>>>>>>>> SHD halt
>>>>>>>>>>>>>>>>>>>>>>>>>> decider can correctly report non-halting.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> A CORRECT non-halting pattern. You haven't
>>>>>>>>>>>>>>>>>>>>>>>>> provided one
>>>>>>>>>>>>>>>>>>>>>>>>> that you have actually proved is correct for
>>>>>>>>>>>>>>>>>>>>>>>>> this case.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> A non-halting behavior pattern is correct
>>>>>>>>>>>>>>>>>>>>>>>>>> when-so-ever
>>>>>>>>>>>>>>>>>>>>>>>>>> matching this behavior pattern proves that
>>>>>>>>>>>>>>>>>>>>>>>>>> the correct
>>>>>>>>>>>>>>>>>>>>>>>>>> and complete simulation of the input by SHD
>>>>>>>>>>>>>>>>>>>>>>>>>> would never
>>>>>>>>>>>>>>>>>>>>>>>>>> reach the final state of this simulated
>>>>>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, since the SHD DOESN'T DO a complete and
>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of thd input, that is an
>>>>>>>>>>>>>>>>>>>>>>>>> INVALID definition.
>>>>>>>>>>>>>>>>>>>>>>>>> Note, you can't change the SHD to be a
>>>>>>>>>>>>>>>>>>>>>>>>> different machine
>>>>>>>>>>>>>>>>>>>>>>>>> if doing so changes the code at the input,
>>>>>>>>>>>>>>>>>>>>>>>>> which includes ALL the code that P calls, not
>>>>>>>>>>>>>>>>>>>>>>>>> just the code inside the "C function" of P.
>>>>>>>>>>>>>>>>>>>>>>>>>> H always reports on what the behavior of its
>>>>>>>>>>>>>>>>>>>>>>>>>> input would be if H was only a simulator and
>>>>>>>>>>>>>>>>>>>>>>>>>> not a simulating halt decider. All simulating
>>>>>>>>>>>>>>>>>>>>>>>>>> halt deciders
>>>>>>>>>>>>>>>>>>>>>>>>>> must abort the simulation of inputs that
>>>>>>>>>>>>>>>>>>>>>>>>>> would never otherwise halt. Here are three
>>>>>>>>>>>>>>>>>>>>>>>>>> examples of that:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>>>>>>>> (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>> (c) is WRONG.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, you admit that H doesn't report the actual
>>>>>>>>>>>>>>>>>>>>>>>>> behavior
>>>>>>>>>>>>>>>>>>>>>>>>> of its input, but only the behavior of some
>>>>>>>>>>>>>>>>>>>>>>>>> other input
>>>>>>>>>>>>>>>>>>>>>>>>> built on a different H.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> A simulating halt decider ALWAYS reports on
>>>>>>>>>>>>>>>>>>>>>>>> what the behavior of its input would be if the
>>>>>>>>>>>>>>>>>>>>>>>> SHD performed a correct and complete simulation
>>>>>>>>>>>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Then a SHD isn't a Halt Decider. PERIOD.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Just by Definition.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> A mere dogmatic assertion utterly bereft of any
>>>>>>>>>>>>>>>>>>>>>> supporting
>>>>>>>>>>>>>>>>>>>>>> reasoning.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> IT IS DEFINITION, something you appearently don't
>>>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>>>> because you are too stupid.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> YOU have quoted the soure of this before, but
>>>>>>>>>>>>>>>>>>>>> apparently your mind can't actually reason or
>>>>>>>>>>>>>>>>>>>>> remember.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *HERE IS A DEFINITION FOR YOU*
>>>>>>>>>>>>>>>>>>>>>> A halt decider must always derive its halt status
>>>>>>>>>>>>>>>>>>>>>> decision
>>>>>>>>>>>>>>>>>>>>>> on the basis of the actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, and the DEFINITION of the "actual behavior"
>>>>>>>>>>>>>>>>>>>>> of the "actual input" for an x86 decider is what
>>>>>>>>>>>>>>>>>>>>> happens when you
>>>>>>>>>>>>>>>>>>>>> run that actual input.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Thus the ACTUAL BEHAVIOR or the input to H(P,P) is
>>>>>>>>>>>>>>>>>>>>> the actual behavor of running P(P)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *HERE IS THE DEFINITION OF A UTM*
>>>>>>>>>>>>>>>>>>>>>> It is common knowledge that the correct and
>>>>>>>>>>>>>>>>>>>>>> complete simulation of a machine description
>>>>>>>>>>>>>>>>>>>>>> always provides the actual behavior specified by
>>>>>>>>>>>>>>>>>>>>>> this machine description.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, UTM(P,d) will ALWAYS behave exactly like
>>>>>>>>>>>>>>>>>>>>> P(d).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> This means that the actual behavior of the actual
>>>>>>>>>>>>>>>>>>>>>> input would be the correct and complete
>>>>>>>>>>>>>>>>>>>>>> simulation of the input
>>>>>>>>>>>>>>>>>>>>>> to H(P,P) at the exact same point in the
>>>>>>>>>>>>>>>>>>>>>> execution trace where H is invoked:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Sort of. Doesn't mean you replace H with a UTM, as
>>>>>>>>>>>>>>>>>>>>> that point is actually a call to H, and is looking
>>>>>>>>>>>>>>>>>>>>> for the Behavior or H which is supposed to be
>>>>>>>>>>>>>>>>>>>>> asking about the behavior of it input, which is
>>>>>>>>>>>>>>>>>>>>> the SEPERATE PROGRA P(P), not as executed "At that
>>>>>>>>>>>>>>>>>>>>> point in the execution trace", but
>>>>>>>>>>>>>>>>>>>>> as an actual computation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I don;t think you know enough about how a program
>>>>>>>>>>>>>>>>>>>>> works to
>>>>>>>>>>>>>>>>>>>>> get into a beginners programming course.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>         int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>>>>> The actual behavior of the actual input is defined
>>>>>>>>>>>>>>>>>>>> as the behavior of the correct and complete
>>>>>>>>>>>>>>>>>>>> simulation of this input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, BUT, P didn't ask for a correct and complete
>>>>>>>>>>>>>>>>>>> simulation
>>>>>>>>>>>>>>>>>>> of the input to H, it wanted a halting decision that
>>>>>>>>>>>>>>>>>>> corresponded to that behavior, and it whated that in
>>>>>>>>>>>>>>>>>>> finite time.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Thus, replacing the call to H with a simulation of
>>>>>>>>>>>>>>>>>>> the input
>>>>>>>>>>>>>>>>>>> to H is not a correct substitution.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is the job of H to correctly predict what the
>>>>>>>>>>>>>>>>>>>> behavior of
>>>>>>>>>>>>>>>>>>>> its input would be if H performed a correct and
>>>>>>>>>>>>>>>>>>>> complete simulation of this input:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, it is to correct predict what the behavior of
>>>>>>>>>>>>>>>>>>> its input
>>>>>>>>>>>>>>>>>>> would be if given to a correct and complete
>>>>>>>>>>>>>>>>>>> simulation of this
>>>>>>>>>>>>>>>>>>> input.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> SInce H DOESN'T DO a correct and complete simulation
>>>>>>>>>>>>>>>>>>> of its input, you statement is nonsence.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> // Never reaches the final state of Infinite_Loop
>>>>>>>>>>>>>>>>>>>> (a) H0(Infinite_Loop)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> // Never reaches the final state of
>>>>>>>>>>>>>>>>>>>> Infinite_Recursion (b) H(Infinite_Recursion, 0x777)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> // Never reaches the final state of P
>>>>>>>>>>>>>>>>>>>> (c) H(P,P)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But doesn't do a correct and complete simulation of
>>>>>>>>>>>>>>>>>>> its input,
>>>>>>>>>>>>>>>>>>> so it didn't establish the needed criteria.
>>>>>>>>>>>>>>>>>> THAT YOU CONTINUE IGNORE KEY WORDS WHEN THEY HAVE
>>>>>>>>>>>>>>>>>> BEEN REPEATED
>>>>>>>>>>>>>>>>>> MANY MANY TIMES LEADS ME TO BELIEVE THAT YOU MIGHT
>>>>>>>>>>>>>>>>>> HAVE ACTUAL
>>>>>>>>>>>>>>>>>> BRAIN DAMAGE.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is the job of H to correctly:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> PREDICT
>>>>>>>>>>>>>>>>>> what the behavior of its input would be if H
>>>>>>>>>>>>>>>>>> performed a correct and complete simulation of this
>>>>>>>>>>>>>>>>>> input: (a) H(P,P) simulates P(P) that calls a
>>>>>>>>>>>>>>>>>> simulated H(P,P) (b) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>> simulated H(P,P) (c) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>> simulated H(P,P) (d) that simulates P(P) that calls a
>>>>>>>>>>>>>>>>>> simulated H(P,P)... (on and on)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You've told us numerous times that H does not do this
>>>>>>>>>>>>>>>>> - you have
>>>>>>>>>>>>>>>>> even explained why it does not do this. So H is not
>>>>>>>>>>>>>>>>> simulating
>>>>>>>>>>>>>>>>> itself correctly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I could have equally been told many times that cats are
>>>>>>>>>>>>>>>> a kind of
>>>>>>>>>>>>>>>> dog, that does not make it true.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A simulating halt decider always predicts what the
>>>>>>>>>>>>>>>> behavior of its input would be if a correct and
>>>>>>>>>>>>>>>> complete simulation of this
>>>>>>>>>>>>>>>> input was performed at the exact same place in the
>>>>>>>>>>>>>>>> execution trace where H is invoked.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void P(ptr x)
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>        int Halt_Status = Simulate(x, x);
>>>>>>>>>>>>>>>>        if (Halt_Status)
>>>>>>>>>>>>>>>>          HERE: goto HERE;
>>>>>>>>>>>>>>>>        return;
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (a) H(P,P) simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>>>>> (b) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>>>>> (c) that simulates P(P) that calls Simulate(P,P)
>>>>>>>>>>>>>>>> (d) that simulates P(P) that calls Simulate(P,P)... (on
>>>>>>>>>>>>>>>> and on)
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But the fact your H is recursive in nature PREVENTS it
>>>>>>>>>>>>>>> from performing a "correct and complete simulation of
>>>>>>>>>>>>>>> this input".  H
>>>>>>>>>>>>>>> deciding the following is non-halting is an ERROR:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void Px(ptr x)
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>       (void)H(x, x);
>>>>>>>>>>>>>>>       return;
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Flibble does not even know enough to know that when
>>>>>>>>>>>>>> H(Px,Px) correctly simulates its input that the "return"
>>>>>>>>>>>>>> instruction is unreachable code by this simulated input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> WRONG. Your H PREVENTS Px from halting and it is INCORRECT
>>>>>>>>>>>>> to do that as a halt decider is supposed to return a
>>>>>>>>>>>>> decision to its caller (Px in this case).
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> In none of these cases will the simulated P(P) ever reach
>>>>>>>>>>>> its own final state:
>>>>>>>>>>>>
>>>>>>>>>>>> void Px(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>>       H(x, x);
>>>>>>>>>>>>       return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void Py(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>>       Simulate(x, x);
>>>>>>>>>>>>       return;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> void Pz(u32 x)
>>>>>>>>>>>> {
>>>>>>>>>>>>       UTM(x, x);
>>>>>>>>>>>>       return;
>>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Error by non-equivalence: a halt decider (i.e. H) is
>>>>>>>>>>> supposed to return
>>>>>>>>>>> a result to its caller in finite time.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> The outermost H returns to its caller, the first inner H is
>>>>>>>>>> aborted before it is even invoked.
>>>>>>>>>
>>>>>>>>> Which mean that an ACTUAL SIMULATION of the  actual input to
>>>>>>>>> H(Px,Px), which would be shown by Simulate(Px,Px) or UTM(Px,
>>>>>>>>> Px) would Halt, and thus H is incorrect.
>>>>>>>>
>>>>>>>> No you brain dead moron and aborted process is not a process
>>>>>>>> that halts.
>>>>>>>> No simulated Px ever reaches its own "return" instruction.
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>> Simulate(Px,Px) shows a simulated Px that reaches its return
>>>>>>> instruction.
>>>>>> More of your God damned strawman deception. I say God damned
>>>>>> because Revelations 21:8 indicates that Liars will be condemned
>>>>>> to Hell by God. "God damned" literally means condemned to Hell by
>>>>>> God.
>>>>>>
>>>>>> NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN "return"
>>>>>> INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER REACHES IT OWN
>>>>>> "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER REACHES
>>>>>> IT OWN "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H EVER
>>>>>> REACHES IT OWN "return" INSTRUCTION. NO Px THAT IS SIMULATED BY H
>>>>>> EVER REACHES IT OWN "return" INSTRUCTION.
>>>>>
>>>>> So?
>>>>>
>>>>> No H that gives an answer does a complete simulation, so it
>>>>> doesn't show the answer to the question.
>>>>>
>>>>> You are just eating your POOP.
>>>>>
>>>>> The Halting Problem is about the behavior of the machine given to
>>>>> the decider, or the complete (and correct) simulation of the input.
>>>>>
>>>>> H is wrong about that, and you have wasted the last 18 years of
>>>>> your life eating POOP and thinking you were doing something.
>>>>>
>>>>> Your Legacy is of a Pathological Lying Idiot.
>>>>>
>>>>> Bye-Bye.
>>>>
>>>
>>> Cat got your tongue?
>>>
>>> Or just caught wordless because you are seeing you have no answer?
>>
>> He is just replying to change the subject line to call you a troll and
>> to say that I am clueless about software engineering.  He really is a
>> fucktard who has got nothing of value to contribute.
>>
>> /Flibble
>>
>
> True.
>
> He is just proving how stupid he is.
>
> He has sealed his eternal legacy at a Pathological Lying Idiot


Click here to read the complete article
Re: Olcott Lies

<dGsOK.889035$ssF.324130@fx14.iad>

  copy mid

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

  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!fx14.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Re: Olcott Lies
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<KZGdnQcEU7vAvZT-nZ2dnZfqlJ9g4p2d@giganews.com>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 37
Message-ID: <dGsOK.889035$ssF.324130@fx14.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 27 Aug 2022 13:40:23 -0400
X-Received-Bytes: 2889
 by: Richard Damon - Sat, 27 Aug 2022 17:40 UTC

On 8/27/22 1:32 PM, olcott wrote:
> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>
>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>
>>>>
>>>> Cat got your tongue?
>>>>
>>>> Or just caught wordless because you are seeing you have no answer?
>>>
>>> He is just replying to change the subject line to call you a troll and
>>> to say that I am clueless about software engineering.  He really is a
>>> fucktard who has got nothing of value to contribute.
>>>
>>> /Flibble
>>>
>>
>> True.
>>
>> He is just proving how stupid he is.
>>
>> He has sealed his eternal legacy at a Pathological Lying Idiot
>
>

Yep, he is just admitting that there is no truth in his statements he is
admitting that he is wrong, but won't actually admit it.

By ignoring the people pointing out errors, he shows that he is only
interested in himself and not what is actually true.

Maybe someone will get permission to dip their finger in water to help you.

Richard is just a Troll

<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 17:44:08 +0000
Date: Sat, 27 Aug 2022 12:44:08 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Richard is just a Troll
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<5y9OK.779720$5fVf.143349@fx09.iad>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <dGsOK.889035$ssF.324130@fx14.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 49
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-lS1DjqRy0XQS2ljqnx8A1voy9zp7haJgte94MmucOqVwK00E4we/y+51GdoCEqkcVFrt4z1sCAmTSOe!xvnXAVBqtbvegOx/iIpXpMBWPO+2g5lnueoCAwMbRsWFieiDzXEmWscK1FHinjdOvWzsi524l78=
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
 by: olcott - Sat, 27 Aug 2022 17:44 UTC

On 8/27/2022 12:40 PM, Richard Damon wrote:
>
> On 8/27/22 1:32 PM, olcott wrote:
>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>
>>>>>
>>>>> Cat got your tongue?
>>>>>
>>>>> Or just caught wordless because you are seeing you have no answer?
>>>>
>>>> He is just replying to change the subject line to call you a troll and
>>>> to say that I am clueless about software engineering.  He really is a
>>>> fucktard who has got nothing of value to contribute.
>>>>
>>>> /Flibble
>>>>
>>>
>>> True.
>>>
>>> He is just proving how stupid he is.
>>>
>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>
>>
>
> Yep, he is just admitting that there is no truth in his statements he is
> admitting that he is wrong, but won't actually admit it.
>
> By ignoring the people pointing out errors, he shows that he is only
> interested in himself and not what is actually true.
>

I have pointed out all of the errors of all of your rebuttals and
instead of addressing these errors you change the subject only to get
back to make these same mistakes again and again.

--
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: Richard is just a Troll

<20220827184921.00005211@reddwarf.jmc.corp>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!npeer.as286.net!npeer-ng0.as286.net!peer03.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx14.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Richard is just a Troll
Message-ID: <20220827184921.00005211@reddwarf.jmc.corp>
References: <20220817174635.00004410@reddwarf.jmc.corp>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp>
<_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 51
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 27 Aug 2022 17:49:22 UTC
Date: Sat, 27 Aug 2022 18:49:21 +0100
X-Received-Bytes: 3206
 by: Mr Flibble - Sat, 27 Aug 2022 17:49 UTC

On Sat, 27 Aug 2022 12:44:08 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 12:40 PM, Richard Damon wrote:
> >
> > On 8/27/22 1:32 PM, olcott wrote:
> >> On 8/27/2022 12:28 PM, Richard Damon wrote:
> >>>
> >>> On 8/27/22 1:04 PM, Mr Flibble wrote:
> >>>> On Sat, 27 Aug 2022 13:02:29 -0400
> >>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>
> >>>>> On 8/27/22 12:55 PM, olcott wrote:
> >>>>>>
> >>>>>
> >>>>> Cat got your tongue?
> >>>>>
> >>>>> Or just caught wordless because you are seeing you have no
> >>>>> answer?
> >>>>
> >>>> He is just replying to change the subject line to call you a
> >>>> troll and to say that I am clueless about software engineering.
> >>>> He really is a fucktard who has got nothing of value to
> >>>> contribute.
> >>>>
> >>>> /Flibble
> >>>>
> >>>
> >>> True.
> >>>
> >>> He is just proving how stupid he is.
> >>>
> >>> He has sealed his eternal legacy at a Pathological Lying Idiot
> >>
> >>
> >
> > Yep, he is just admitting that there is no truth in his statements
> > he is admitting that he is wrong, but won't actually admit it.
> >
> > By ignoring the people pointing out errors, he shows that he is
> > only interested in himself and not what is actually true.
> >
>
> I have pointed out all of the errors of all of your rebuttals and
> instead of addressing these errors you change the subject only to get
> back to make these same mistakes again and again.

Classic case of psychological projection. You really are a nutter!

/Flibble

Re: Richard is just a Troll

<BfGdnRFpgfK9wJf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 18:06:24 +0000
Date: Sat, 27 Aug 2022 13:06:23 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Richard is just a Troll
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827184921.00005211@reddwarf.jmc.corp>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <20220827184921.00005211@reddwarf.jmc.corp>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Message-ID: <BfGdnRFpgfK9wJf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 63
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-sVQb/7lIjhI/nfRTf6HaKBcCD5Hr/ML68dqeHrgS4ktQJ45rmqImY9AhoEvC/odX4cPBUWVe86tXIs8!2/witkw4W+I1FE/R55AE1o86ama893tUWcfrm8ChiqfgWadq4ARLVUrG7+ECDiJf4JOOuPWXiM8=
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
 by: olcott - Sat, 27 Aug 2022 18:06 UTC

On 8/27/2022 12:49 PM, Mr Flibble wrote:
> On Sat, 27 Aug 2022 12:44:08 -0500
> olcott <NoOne@NoWhere.com> wrote:
>
>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 1:32 PM, olcott wrote:
>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>
>>>>>>>
>>>>>>> Cat got your tongue?
>>>>>>>
>>>>>>> Or just caught wordless because you are seeing you have no
>>>>>>> answer?
>>>>>>
>>>>>> He is just replying to change the subject line to call you a
>>>>>> troll and to say that I am clueless about software engineering.
>>>>>> He really is a fucktard who has got nothing of value to
>>>>>> contribute.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> True.
>>>>>
>>>>> He is just proving how stupid he is.
>>>>>
>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>
>>>>
>>>
>>> Yep, he is just admitting that there is no truth in his statements
>>> he is admitting that he is wrong, but won't actually admit it.
>>>
>>> By ignoring the people pointing out errors, he shows that he is
>>> only interested in himself and not what is actually true.
>>>
>>
>> I have pointed out all of the errors of all of your rebuttals and
>> instead of addressing these errors you change the subject only to get
>> back to make these same mistakes again and again.
>
> Classic case of psychological projection. You really are a nutter!
>
> /Flibble
>

You lack the technical competence to provide technical reasoning to show
otherwise. All that you have is mere rhetoric utterly bereft of any
correct technical reasoning.

--
Copyright 2022 Pete Olcott

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

Olcott is just a Pathological Liar

<i3tOK.1116035$X_i.273028@fx18.iad>

  copy mid

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

  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!fx18.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Olcott is just a Pathological Liar
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<efqdnZqh0L2UsZT-nZ2dnZfqlJzNnZ2d@giganews.com>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 62
Message-ID: <i3tOK.1116035$X_i.273028@fx18.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 27 Aug 2022 14:07:10 -0400
X-Received-Bytes: 3831
 by: Richard Damon - Sat, 27 Aug 2022 18:07 UTC

On 8/27/22 1:44 PM, olcott wrote:
> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>
>> On 8/27/22 1:32 PM, olcott wrote:
>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>
>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>
>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>
>>>>>>
>>>>>> Cat got your tongue?
>>>>>>
>>>>>> Or just caught wordless because you are seeing you have no answer?
>>>>>
>>>>> He is just replying to change the subject line to call you a troll and
>>>>> to say that I am clueless about software engineering.  He really is a
>>>>> fucktard who has got nothing of value to contribute.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> True.
>>>>
>>>> He is just proving how stupid he is.
>>>>
>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>
>>>
>>
>> Yep, he is just admitting that there is no truth in his statements he
>> is admitting that he is wrong, but won't actually admit it.
>>
>> By ignoring the people pointing out errors, he shows that he is only
>> interested in himself and not what is actually true.
>>
>
> I have pointed out all of the errors of all of your rebuttals and
> instead of addressing these errors you change the subject only to get
> back to make these same mistakes again and again.
>
>

Really, point to an error I have made that you pointed out to any source
other than "yourself" as grounds for me being wrong.

I don't think you KNOW HOW to actually deal with a rebuttal.

Note, I DON'T change the subject, I go to the core of what you are
talking about, and you object to that as I don't let you build up a bed
of half truths to try to make you ideas seem possibly plausable.

Unless you ADMIT that you aren't talking about the Halting Theorm, all
my comments are "On Topic" as I am just pointing out the basic
definitions of the theory.

YOU are the one that changes the subject.

YOU FAIL.

Re: Richard is just a Troll

<20220827190944.00000c8e@reddwarf.jmc.corp>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!usenet.blueworldhosting.com!feed1.usenet.blueworldhosting.com!peer02.iad!feed-me.highwinds-media.com!peer02.ams4!peer.am4.highwinds-media.com!news.highwinds-media.com!fx05.ams4.POSTED!not-for-mail
From: flib...@reddwarf.jmc.corp (Mr Flibble)
Newsgroups: comp.theory
Subject: Re: Richard is just a Troll
Message-ID: <20220827190944.00000c8e@reddwarf.jmc.corp>
References: <20220817174635.00004410@reddwarf.jmc.corp>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp>
<_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827184921.00005211@reddwarf.jmc.corp>
<BfGdnRFpgfK9wJf-nZ2dnZfqlJzNnZ2d@giganews.com>
Organization: Jupiter Mining Corporation
X-Newsreader: Claws Mail 4.1.0 (GTK 3.24.33; x86_64-w64-mingw32)
MIME-Version: 1.0
Content-Type: text/plain; charset=US-ASCII
Content-Transfer-Encoding: 7bit
Lines: 66
X-Complaints-To: abuse@eweka.nl
NNTP-Posting-Date: Sat, 27 Aug 2022 18:09:44 UTC
Date: Sat, 27 Aug 2022 19:09:44 +0100
X-Received-Bytes: 3826
 by: Mr Flibble - Sat, 27 Aug 2022 18:09 UTC

On Sat, 27 Aug 2022 13:06:23 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/27/2022 12:49 PM, Mr Flibble wrote:
> > On Sat, 27 Aug 2022 12:44:08 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/27/2022 12:40 PM, Richard Damon wrote:
> >>>
> >>> On 8/27/22 1:32 PM, olcott wrote:
> >>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
> >>>>>
> >>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
> >>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
> >>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>
> >>>>>>> On 8/27/22 12:55 PM, olcott wrote:
> >>>>>>>>
> >>>>>>>
> >>>>>>> Cat got your tongue?
> >>>>>>>
> >>>>>>> Or just caught wordless because you are seeing you have no
> >>>>>>> answer?
> >>>>>>
> >>>>>> He is just replying to change the subject line to call you a
> >>>>>> troll and to say that I am clueless about software engineering.
> >>>>>> He really is a fucktard who has got nothing of value to
> >>>>>> contribute.
> >>>>>>
> >>>>>> /Flibble
> >>>>>>
> >>>>>
> >>>>> True.
> >>>>>
> >>>>> He is just proving how stupid he is.
> >>>>>
> >>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
> >>>>
> >>>>
> >>>
> >>> Yep, he is just admitting that there is no truth in his statements
> >>> he is admitting that he is wrong, but won't actually admit it.
> >>>
> >>> By ignoring the people pointing out errors, he shows that he is
> >>> only interested in himself and not what is actually true.
> >>>
> >>
> >> I have pointed out all of the errors of all of your rebuttals and
> >> instead of addressing these errors you change the subject only to
> >> get back to make these same mistakes again and again.
> >
> > Classic case of psychological projection. You really are a nutter!
> >
> > /Flibble
> >
>
> You lack the technical competence to provide technical reasoning to
> show otherwise. All that you have is mere rhetoric utterly bereft of
> any correct technical reasoning.

All my previous posts in this forum tell a different story, dear. I
suggest you get your medication reviewed by your psychiatrist: you are
taking your medication aren't you?

/Flibble

Richard is a Troll [ rebuttal to all of Richards rebuttals ]

<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 18:28:42 +0000
Date: Sat, 27 Aug 2022 13:28:41 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Richard is a Troll [ rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<5a855041-18e8-4c16-a1bd-b129b775b60cn@googlegroups.com>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <i3tOK.1116035$X_i.273028@fx18.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 86
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-hmXh9RGHK2xMVqeSZYCU3nLIK7ozbLV35xjdYRXU3Q3EhFjmIkQo1VPf5D69sKieTBJty0+qDBaUsD8!Od69UXmXeoNcxIWJrDvM+yW0J+TlbJcDzmex6Cuzf6w19ZEsufcjqDea5YsXpsK86LYpzWZdeJQ=
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
 by: olcott - Sat, 27 Aug 2022 18:28 UTC

On 8/27/2022 1:07 PM, Richard Damon wrote:
>
> On 8/27/22 1:44 PM, olcott wrote:
>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 1:32 PM, olcott wrote:
>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>
>>>>>>>
>>>>>>> Cat got your tongue?
>>>>>>>
>>>>>>> Or just caught wordless because you are seeing you have no answer?
>>>>>>
>>>>>> He is just replying to change the subject line to call you a troll
>>>>>> and
>>>>>> to say that I am clueless about software engineering.  He really is a
>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> True.
>>>>>
>>>>> He is just proving how stupid he is.
>>>>>
>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>
>>>>
>>>
>>> Yep, he is just admitting that there is no truth in his statements he
>>> is admitting that he is wrong, but won't actually admit it.
>>>
>>> By ignoring the people pointing out errors, he shows that he is only
>>> interested in himself and not what is actually true.
>>>
>>
>> I have pointed out all of the errors of all of your rebuttals and
>> instead of addressing these errors you change the subject only to get
>> back to make these same mistakes again and again.
>>
>>
>
> Really, point to an error I have made that you pointed out to any source
> other than "yourself" as grounds for me being wrong.
>
> I don't think you KNOW HOW to actually deal with a rebuttal.
>
> Note, I DON'T change the subject, I go to the core of what you are
> talking about, and you object to that as I don't let you build up a bed
> of half truths to try to make you ideas seem possibly plausable.
>
> Unless you ADMIT that you aren't talking about the Halting Theorm, all
> my comments are "On Topic" as I am just pointing out the basic
> definitions of the theory.
>
> YOU are the one that changes the subject.
>
> YOU FAIL.

*THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
The correct and complete simulation of a machine description always
provides the actual behavior specified by this machine description.

*THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
When-so-ever a simulating halt decider (SHD) correctly performs a
partial simulation of its input and the behavior of this partial
simulation correctly matches a correct non-halting behavior pattern then
the SHD halt decider can correctly report non-halting.

*THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
A non-halting behavior pattern is correct when-so-ever matching this
behavior pattern proves that the simulated input to the SHD would never
stop running unless the SHD aborted its simulation.

--
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: Olcott is a Liar and doesn't understand what he says.

<fBtOK.1187$SqO3.795@fx02.iad>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!newsreader4.netcologne.de!news.netcologne.de!peer02.ams1!peer.ams1.xlned.com!news.xlned.com!peer03.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx02.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Re: Olcott is a Liar and doesn't understand what he says.
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 123
Message-ID: <fBtOK.1187$SqO3.795@fx02.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 27 Aug 2022 14:43:22 -0400
X-Received-Bytes: 6494
 by: Richard Damon - Sat, 27 Aug 2022 18:43 UTC

On 8/27/22 2:28 PM, olcott wrote:
> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>
>> On 8/27/22 1:44 PM, olcott wrote:
>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>
>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>
>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>
>>>>>>>>
>>>>>>>> Cat got your tongue?
>>>>>>>>
>>>>>>>> Or just caught wordless because you are seeing you have no answer?
>>>>>>>
>>>>>>> He is just replying to change the subject line to call you a
>>>>>>> troll and
>>>>>>> to say that I am clueless about software engineering.  He really
>>>>>>> is a
>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>
>>>>>>> /Flibble
>>>>>>>
>>>>>>
>>>>>> True.
>>>>>>
>>>>>> He is just proving how stupid he is.
>>>>>>
>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>
>>>>>
>>>>
>>>> Yep, he is just admitting that there is no truth in his statements
>>>> he is admitting that he is wrong, but won't actually admit it.
>>>>
>>>> By ignoring the people pointing out errors, he shows that he is only
>>>> interested in himself and not what is actually true.
>>>>
>>>
>>> I have pointed out all of the errors of all of your rebuttals and
>>> instead of addressing these errors you change the subject only to get
>>> back to make these same mistakes again and again.
>>>
>>>
>>
>> Really, point to an error I have made that you pointed out to any
>> source other than "yourself" as grounds for me being wrong.
>>
>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>
>> Note, I DON'T change the subject, I go to the core of what you are
>> talking about, and you object to that as I don't let you build up a
>> bed of half truths to try to make you ideas seem possibly plausable.
>>
>> Unless you ADMIT that you aren't talking about the Halting Theorm, all
>> my comments are "On Topic" as I am just pointing out the basic
>> definitions of the theory.
>>
>> YOU are the one that changes the subject.
>>
>> YOU FAIL.
>
> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
> The correct and complete simulation of a machine description always
> provides the actual behavior specified by this machine description.

Correct, and the machine description includes ALL the code executed by
the program, including all subroutines/function it calls.

>
> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
> When-so-ever a simulating halt decider (SHD) correctly performs a
> partial simulation of its input and the behavior of this partial
> simulation correctly matches a correct non-halting behavior pattern then
> the SHD halt decider can correctly report non-halting.

Yes, A CORRECT non-halting behavior pattern.

>
> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
> A non-halting behavior pattern is correct when-so-ever matching this
> behavior pattern proves that the simulated input to the SHD would never
> stop running unless the SHD aborted its simulation.
>

WRONG, proving you are a LIAR, and and idiot.

A non-halting behavior pattern is a pattern that means that a correct
and complete simulation could never stop after seeing that pattern, in
any machine.

Halting is a property of the MACHINE, that is the MACHINE the input
specified.

Non-halting means that MACHINE never reaches a final state ever, even
after an unbounded number of steps.

Your definition is illogical, as you can only look at the behavior of
the program you HAVE, that is the SHD as defined. Since it aborts, we
can't talk about the behavior of the system if we redefined the machine
to be something else in a way that affect other machines in the system
(like P).

It is clear that your definition MUST be wrong, as it leads to
contradictions.

We Know, and you have aggreed, the P(P) will Halt if H(P,P) returns 0.
This shows that the answer is wrong.

You try to "fix" this problem my asserting that the input to H(P,P) must
not represent P(P) to get around this contradiction, but then P doesn't
meet its requirement to ask H about itself applied to its represention,
which it does by calling H(P,P), so if that doesn't ask about P(P), your
P is definied wrong.

All you have done is shown that you don't understand how logic works,
and what the actual definitions mean.

Richard is a Troll [ rebuttal to all of Richards rebuttals ]

<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!aioe.org!news.uzoreto.com!tr3.eu1.usenetexpress.com!feeder.usenetexpress.com!tr3.iad1.usenetexpress.com!69.80.99.27.MISMATCH!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 18:57:13 +0000
Date: Sat, 27 Aug 2022 13:57:13 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101 Thunderbird/91.13.0
Subject: Richard is a Troll [ rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp> <rYudnWueaPJWqJT-nZ2dnZfqlJzNnZ2d@giganews.com> <20220826222359.00006d1e@reddwarf.jmc.corp> <79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com> <20220827004929.00001ee1@reddwarf.jmc.corp> <RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com> <20220827120807.000078f7@reddwarf.jmc.corp> <EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com> <IgqOK.883609$70j.372919@fx16.iad> <Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com> <luqOK.839174$J0r9.207864@fx11.iad> <iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com> <ZXqOK.782930$5fVf.780439@fx09.iad> <_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com> <F6sOK.841862$J0r9.210570@fx11.iad> <20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad> <6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com> <dGsOK.889035$ssF.324130@fx14.iad> <uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com> <i3tOK.1116035$X_i.273028@fx18.iad> <EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com> <fBtOK.1187$SqO3.795@fx02.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <fBtOK.1187$SqO3.795@fx02.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 192
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-Vym8Jlns0QXODSvV65Sq5JRkjJA73J+zw7vR9yeDK27uetouNAkVWOHs1Q173b6/Ax5ukCvWm48ENXQ!7wDr8pIx3h+FkGwNgENbR6LtGWmrPhEo+tp6jWnQVewRP+l0HCVR4JqXgkp5B4EEWDJo+KeGL+U=
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
 by: olcott - Sat, 27 Aug 2022 18:57 UTC

On 8/27/2022 1:43 PM, Richard Damon wrote:
>
> On 8/27/22 2:28 PM, olcott wrote:
>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 1:44 PM, olcott wrote:
>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>
>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Cat got your tongue?
>>>>>>>>>
>>>>>>>>> Or just caught wordless because you are seeing you have no answer?
>>>>>>>>
>>>>>>>> He is just replying to change the subject line to call you a
>>>>>>>> troll and
>>>>>>>> to say that I am clueless about software engineering.  He really
>>>>>>>> is a
>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> True.
>>>>>>>
>>>>>>> He is just proving how stupid he is.
>>>>>>>
>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>
>>>>>>
>>>>>
>>>>> Yep, he is just admitting that there is no truth in his statements
>>>>> he is admitting that he is wrong, but won't actually admit it.
>>>>>
>>>>> By ignoring the people pointing out errors, he shows that he is
>>>>> only interested in himself and not what is actually true.
>>>>>
>>>>
>>>> I have pointed out all of the errors of all of your rebuttals and
>>>> instead of addressing these errors you change the subject only to
>>>> get back to make these same mistakes again and again.
>>>>
>>>>
>>>
>>> Really, point to an error I have made that you pointed out to any
>>> source other than "yourself" as grounds for me being wrong.
>>>
>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>
>>> Note, I DON'T change the subject, I go to the core of what you are
>>> talking about, and you object to that as I don't let you build up a
>>> bed of half truths to try to make you ideas seem possibly plausable.
>>>
>>> Unless you ADMIT that you aren't talking about the Halting Theorm,
>>> all my comments are "On Topic" as I am just pointing out the basic
>>> definitions of the theory.
>>>
>>> YOU are the one that changes the subject.
>>>
>>> YOU FAIL.
>>
>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>> The correct and complete simulation of a machine description always
>> provides the actual behavior specified by this machine description.
>
> Correct, and the machine description includes ALL the code executed by
> the program, including all subroutines/function it calls.
>
>>
>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>> When-so-ever a simulating halt decider (SHD) correctly performs a
>> partial simulation of its input and the behavior of this partial
>> simulation correctly matches a correct non-halting behavior pattern
>> then the SHD halt decider can correctly report non-halting.
>
> Yes, A CORRECT non-halting behavior pattern.
>
>>
>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>> A non-halting behavior pattern is correct when-so-ever matching this
>> behavior pattern proves that the simulated input to the SHD would
>> never stop running unless the SHD aborted its simulation.
>>
>
> WRONG, proving you are a LIAR, and and idiot.
>
> A non-halting behavior pattern is a pattern that means that a correct
> and complete simulation could never stop after seeing that pattern, in
> any machine.
>

No it doesn't mean anything like that.

Example 01:
H0 correctly determines that Infinite_Loop() never halts

void Infinite_Loop()
{ HERE: goto HERE;
}

int main()
{ Output("Input_Halts = ", H0((u32)Infinite_Loop));
}

_Infinite_Loop()
[00001102](01) 55 push ebp
[00001103](02) 8bec mov ebp,esp
[00001105](02) ebfe jmp 00001105
[00001107](01) 5d pop ebp
[00001108](01) c3 ret
Size in bytes:(0007) [00001108]

_main()
[00001192](01) 55 push ebp
[00001193](02) 8bec mov ebp,esp
[00001195](05) 6802110000 push 00001102
[0000119a](05) e8d3fbffff call 00000d72
[0000119f](03) 83c404 add esp,+04
[000011a2](01) 50 push eax
[000011a3](05) 68a3040000 push 000004a3
[000011a8](05) e845f3ffff call 000004f2
[000011ad](03) 83c408 add esp,+08
[000011b0](02) 33c0 xor eax,eax
[000011b2](01) 5d pop ebp
[000011b3](01) c3 ret
Size in bytes:(0034) [000011b3]

machine stack stack machine assembly
address address data code language
======== ======== ======== ========= =============
[00001192][00101ef8][00000000] 55 push ebp
[00001193][00101ef8][00000000] 8bec mov ebp,esp
[00001195][00101ef4][00001102] 6802110000 push 00001102
[0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72

H0: Begin Simulation Execution Trace Stored at:211fac
[00001102][00211f9c][00211fa0] 55 push ebp
[00001103][00211f9c][00211fa0] 8bec mov ebp,esp
[00001105][00211f9c][00211fa0] ebfe jmp 00001105
[00001105][00211f9c][00211fa0] ebfe jmp 00001105
H0: Infinite Loop Detected Simulation Stopped

if (current->Simplified_Opcode == JMP) // JMP
if (current->Decode_Target <= current->Address) // upward
if (traced->Address == current->Decode_Target) // to this address
if (Conditional_Branch_Count == 0) // no escape
return 1;

[0000119f][00101ef8][00000000] 83c404 add esp,+04
[000011a2][00101ef4][00000000] 50 push eax
[000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
[000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
Input_Halts = 0
[000011ad][00101ef8][00000000] 83c408 add esp,+08
[000011b0][00101ef8][00000000] 33c0 xor eax,eax
[000011b2][00101efc][00100000] 5d pop ebp
[000011b3][00101f00][00000004] c3 ret
Number of Instructions Executed(554) == 8 Pages

> Halting is a property of the MACHINE, that is the MACHINE the input
> specified.

If halt deciders examined machines you would be correct.
Halt deciders never examine machines.
Halt deciders always examine finite string machine descriptions.

Because a simulating halt decider is a pure simulator that has extra
features added to it a simulating halt decider that never aborts its
simulation is simply a pure simulator thus

A non-halting behavior pattern is correct when-so-ever matching this
behavior pattern proves that the simulated input to the SHD would
never stop running unless the SHD aborted its simulation.

--
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: Richard is a Troll [ rebuttal to all of Richards rebuttals ]

<o9uOK.1189$SqO3.1094@fx02.iad>

  copy mid

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

  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!fx02.iad.POSTED!not-for-mail
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:91.0)
Gecko/20100101 Thunderbird/91.13.0
Subject: Re: Richard is a Troll [ rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<20220826222359.00006d1e@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 235
Message-ID: <o9uOK.1189$SqO3.1094@fx02.iad>
X-Complaints-To: abuse@easynews.com
Organization: Forte - www.forteinc.com
X-Complaints-Info: Please be sure to forward a copy of ALL headers otherwise we will be unable to process your complaint properly.
Date: Sat, 27 Aug 2022 15:21:55 -0400
X-Received-Bytes: 10834
 by: Richard Damon - Sat, 27 Aug 2022 19:21 UTC

On 8/27/22 2:57 PM, olcott wrote:
> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>
>> On 8/27/22 2:28 PM, olcott wrote:
>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>
>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>
>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>
>>>>>>>>>> Or just caught wordless because you are seeing you have no
>>>>>>>>>> answer?
>>>>>>>>>
>>>>>>>>> He is just replying to change the subject line to call you a
>>>>>>>>> troll and
>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>> really is a
>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>
>>>>>>>> True.
>>>>>>>>
>>>>>>>> He is just proving how stupid he is.
>>>>>>>>
>>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yep, he is just admitting that there is no truth in his statements
>>>>>> he is admitting that he is wrong, but won't actually admit it.
>>>>>>
>>>>>> By ignoring the people pointing out errors, he shows that he is
>>>>>> only interested in himself and not what is actually true.
>>>>>>
>>>>>
>>>>> I have pointed out all of the errors of all of your rebuttals and
>>>>> instead of addressing these errors you change the subject only to
>>>>> get back to make these same mistakes again and again.
>>>>>
>>>>>
>>>>
>>>> Really, point to an error I have made that you pointed out to any
>>>> source other than "yourself" as grounds for me being wrong.
>>>>
>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>
>>>> Note, I DON'T change the subject, I go to the core of what you are
>>>> talking about, and you object to that as I don't let you build up a
>>>> bed of half truths to try to make you ideas seem possibly plausable.
>>>>
>>>> Unless you ADMIT that you aren't talking about the Halting Theorm,
>>>> all my comments are "On Topic" as I am just pointing out the basic
>>>> definitions of the theory.
>>>>
>>>> YOU are the one that changes the subject.
>>>>
>>>> YOU FAIL.
>>>
>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>> The correct and complete simulation of a machine description always
>>> provides the actual behavior specified by this machine description.
>>
>> Correct, and the machine description includes ALL the code executed by
>> the program, including all subroutines/function it calls.
>>
>>>
>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>> When-so-ever a simulating halt decider (SHD) correctly performs a
>>> partial simulation of its input and the behavior of this partial
>>> simulation correctly matches a correct non-halting behavior pattern
>>> then the SHD halt decider can correctly report non-halting.
>>
>> Yes, A CORRECT non-halting behavior pattern.
>>
>>>
>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>> A non-halting behavior pattern is correct when-so-ever matching this
>>> behavior pattern proves that the simulated input to the SHD would
>>> never stop running unless the SHD aborted its simulation.
>>>
>>
>> WRONG, proving you are a LIAR, and and idiot.
>>
>> A non-halting behavior pattern is a pattern that means that a correct
>> and complete simulation could never stop after seeing that pattern, in
>> any machine.
>>
>
> No it doesn't mean anything like that.

You have a reference for that, or are you going to just use incorrect
logic to try to make your point.

>
> Example 01:
> H0 correctly determines that Infinite_Loop() never halts
>
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> int main()
> {
>   Output("Input_Halts = ", H0((u32)Infinite_Loop));
> }
>
> _Infinite_Loop()
> [00001102](01)  55         push ebp
> [00001103](02)  8bec       mov ebp,esp
> [00001105](02)  ebfe       jmp 00001105
> [00001107](01)  5d         pop ebp
> [00001108](01)  c3         ret
> Size in bytes:(0007) [00001108]
>
> _main()
> [00001192](01)  55         push ebp
> [00001193](02)  8bec       mov ebp,esp
> [00001195](05)  6802110000 push 00001102
> [0000119a](05)  e8d3fbffff call 00000d72
> [0000119f](03)  83c404     add esp,+04
> [000011a2](01)  50         push eax
> [000011a3](05)  68a3040000 push 000004a3
> [000011a8](05)  e845f3ffff call 000004f2
> [000011ad](03)  83c408     add esp,+08
> [000011b0](02)  33c0       xor eax,eax
> [000011b2](01)  5d         pop ebp
> [000011b3](01)  c3         ret
> Size in bytes:(0034) [000011b3]
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001192][00101ef8][00000000] 55         push ebp
> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
> [00001195][00101ef4][00001102] 6802110000 push 00001102
> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>
> H0: Begin Simulation   Execution Trace Stored at:211fac
> [00001102][00211f9c][00211fa0] 55         push ebp
> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
> H0: Infinite Loop Detected Simulation Stopped
>
>  if (current->Simplified_Opcode == JMP)           // JMP
>   if (current->Decode_Target <= current->Address) // upward
>    if (traced->Address == current->Decode_Target) // to this address
>     if (Conditional_Branch_Count == 0)            // no escape
>      return 1;
>
> [0000119f][00101ef8][00000000] 83c404     add esp,+04
> [000011a2][00101ef4][00000000] 50         push eax
> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
> Input_Halts = 0
> [000011ad][00101ef8][00000000] 83c408     add esp,+08
> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
> [000011b2][00101efc][00100000] 5d         pop ebp
> [000011b3][00101f00][00000004] c3         ret
> Number of Instructions Executed(554) == 8 Pages
>
>> Halting is a property of the MACHINE, that is the MACHINE the input
>> specified.
>
> If halt deciders examined machines you would be correct.
> Halt deciders never examine machines.
> Halt deciders always examine finite string machine descriptions.

Isn't the finite string the machine code?

I thought you defined your "finite string" to BE the machine code for
your machine.

>
> Because a simulating halt decider is a pure simulator that has extra
> features added to it a simulating halt decider that never aborts its
> simulation is simply a pure simulator thus

So does your H abort its simulation or not.


Click here to read the complete article
Re: Richard is a Troll [ rebuttal to all of Richards rebuttals ]

<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 19:32:46 +0000
Date: Sat, 27 Aug 2022 14:32:46 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Richard is a Troll [ rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<79ednSv3F-zuo5T-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <o9uOK.1189$SqO3.1094@fx02.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 231
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-2jg/zlId+b/O2NH6vvspNXSU+rHFrta1/2LGx9iscBr98MujbC2tHOLzqJ9XWvPG2XxfIE+q7HmtJRh!jwdWIof9bXa0PJURT5GsiXGGwbHnxYoIwkQJzLXQ3cqri7H+KyIpjTZJEMNYmyzkIuC4PZZo2qA=
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
 by: olcott - Sat, 27 Aug 2022 19:32 UTC

On 8/27/2022 2:21 PM, Richard Damon wrote:
> On 8/27/22 2:57 PM, olcott wrote:
>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 2:28 PM, olcott wrote:
>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>
>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>
>>>>>>>>>>> Or just caught wordless because you are seeing you have no
>>>>>>>>>>> answer?
>>>>>>>>>>
>>>>>>>>>> He is just replying to change the subject line to call you a
>>>>>>>>>> troll and
>>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>>> really is a
>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> True.
>>>>>>>>>
>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>
>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>> statements he is admitting that he is wrong, but won't actually
>>>>>>> admit it.
>>>>>>>
>>>>>>> By ignoring the people pointing out errors, he shows that he is
>>>>>>> only interested in himself and not what is actually true.
>>>>>>>
>>>>>>
>>>>>> I have pointed out all of the errors of all of your rebuttals and
>>>>>> instead of addressing these errors you change the subject only to
>>>>>> get back to make these same mistakes again and again.
>>>>>>
>>>>>>
>>>>>
>>>>> Really, point to an error I have made that you pointed out to any
>>>>> source other than "yourself" as grounds for me being wrong.
>>>>>
>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>
>>>>> Note, I DON'T change the subject, I go to the core of what you are
>>>>> talking about, and you object to that as I don't let you build up a
>>>>> bed of half truths to try to make you ideas seem possibly plausable.
>>>>>
>>>>> Unless you ADMIT that you aren't talking about the Halting Theorm,
>>>>> all my comments are "On Topic" as I am just pointing out the basic
>>>>> definitions of the theory.
>>>>>
>>>>> YOU are the one that changes the subject.
>>>>>
>>>>> YOU FAIL.
>>>>
>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>> The correct and complete simulation of a machine description always
>>>> provides the actual behavior specified by this machine description.
>>>
>>> Correct, and the machine description includes ALL the code executed
>>> by the program, including all subroutines/function it calls.
>>>
>>>>
>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>> When-so-ever a simulating halt decider (SHD) correctly performs a
>>>> partial simulation of its input and the behavior of this partial
>>>> simulation correctly matches a correct non-halting behavior pattern
>>>> then the SHD halt decider can correctly report non-halting.
>>>
>>> Yes, A CORRECT non-halting behavior pattern.
>>>
>>>>
>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>> A non-halting behavior pattern is correct when-so-ever matching this
>>>> behavior pattern proves that the simulated input to the SHD would
>>>> never stop running unless the SHD aborted its simulation.
>>>>
>>>
>>> WRONG, proving you are a LIAR, and and idiot.
>>>
>>> A non-halting behavior pattern is a pattern that means that a correct
>>> and complete simulation could never stop after seeing that pattern,
>>> in any machine.
>>>
>>
>> No it doesn't mean anything like that.
>
> You have a reference for that, or are you going to just use incorrect
> logic to try to make your point.
>
>>
>> Example 01:
>> H0 correctly determines that Infinite_Loop() never halts
>>
>> void Infinite_Loop()
>> {
>>    HERE: goto HERE;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>> }
>>
>> _Infinite_Loop()
>> [00001102](01)  55         push ebp
>> [00001103](02)  8bec       mov ebp,esp
>> [00001105](02)  ebfe       jmp 00001105
>> [00001107](01)  5d         pop ebp
>> [00001108](01)  c3         ret
>> Size in bytes:(0007) [00001108]
>>
>> _main()
>> [00001192](01)  55         push ebp
>> [00001193](02)  8bec       mov ebp,esp
>> [00001195](05)  6802110000 push 00001102
>> [0000119a](05)  e8d3fbffff call 00000d72
>> [0000119f](03)  83c404     add esp,+04
>> [000011a2](01)  50         push eax
>> [000011a3](05)  68a3040000 push 000004a3
>> [000011a8](05)  e845f3ffff call 000004f2
>> [000011ad](03)  83c408     add esp,+08
>> [000011b0](02)  33c0       xor eax,eax
>> [000011b2](01)  5d         pop ebp
>> [000011b3](01)  c3         ret
>> Size in bytes:(0034) [000011b3]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [00001192][00101ef8][00000000] 55         push ebp
>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>
>> H0: Begin Simulation   Execution Trace Stored at:211fac
>> [00001102][00211f9c][00211fa0] 55         push ebp
>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>> H0: Infinite Loop Detected Simulation Stopped
>>
>>   if (current->Simplified_Opcode == JMP)           // JMP
>>    if (current->Decode_Target <= current->Address) // upward
>>     if (traced->Address == current->Decode_Target) // to this address
>>      if (Conditional_Branch_Count == 0)            // no escape
>>       return 1;
>>
>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>> [000011a2][00101ef4][00000000] 50         push eax
>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>> Input_Halts = 0
>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>> [000011b2][00101efc][00100000] 5d         pop ebp
>> [000011b3][00101f00][00000004] c3         ret
>> Number of Instructions Executed(554) == 8 Pages
>>
>>> Halting is a property of the MACHINE, that is the MACHINE the input
>>> specified.
>>
>> If halt deciders examined machines you would be correct.
>> Halt deciders never examine machines.
>> Halt deciders always examine finite string machine descriptions.
>
> Isn't the finite string the machine code?
>
> I thought you defined your "finite string" to BE the machine code for
> your machine.
>
>
>>
>> Because a simulating halt decider is a pure simulator that has extra
>> features added to it a simulating halt decider that never aborts its
>> simulation is simply a pure simulator thus
>
> So does your H abort its simulation or not.
>
> If it doesn't, then YES, it does a pure simulation and thus doesn't stop
> until the input reaches a final state, and thus never answers for a
> non-halting input, or
>
> if it DOES, then it can't be the source of what a pure simulator does,
> since it isn't one.
>
> Pleae show me a program that does BOTH be a pure simulator that
> simulates the non-halting input until it (never) reaches the final
> state, and also aborts its simulation to return the non-halting answer,
> at the same time.
>
>
>
>>
>> A non-halting behavior pattern is correct when-so-ever matching this
>> behavior pattern proves that the simulated input to the SHD would
>> never stop running unless the SHD aborted its simulation.
>>
>
> Nope. Proven wrong and illogical. You can't ask about behavior of a
> program (the SHD) that isn't part of the system. The "non-aborting" SHD
> is NOT the SHD, so you condition just doesn't occur.


Click here to read the complete article
Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]

<zzuOK.876382$ntj.37244@fx15.iad>

  copy mid

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

  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!fx15.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.13.0
Subject: Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<20220827004929.00001ee1@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 274
Message-ID: <zzuOK.876382$ntj.37244@fx15.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, 27 Aug 2022 15:49:51 -0400
X-Received-Bytes: 12604
 by: Richard Damon - Sat, 27 Aug 2022 19:49 UTC

On 8/27/22 3:32 PM, olcott wrote:
> On 8/27/2022 2:21 PM, Richard Damon wrote:
>> On 8/27/22 2:57 PM, olcott wrote:
>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>
>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>
>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>
>>>>>>>>>>>> Or just caught wordless because you are seeing you have no
>>>>>>>>>>>> answer?
>>>>>>>>>>>
>>>>>>>>>>> He is just replying to change the subject line to call you a
>>>>>>>>>>> troll and
>>>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>>>> really is a
>>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> True.
>>>>>>>>>>
>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>
>>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>>> statements he is admitting that he is wrong, but won't actually
>>>>>>>> admit it.
>>>>>>>>
>>>>>>>> By ignoring the people pointing out errors, he shows that he is
>>>>>>>> only interested in himself and not what is actually true.
>>>>>>>>
>>>>>>>
>>>>>>> I have pointed out all of the errors of all of your rebuttals and
>>>>>>> instead of addressing these errors you change the subject only to
>>>>>>> get back to make these same mistakes again and again.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Really, point to an error I have made that you pointed out to any
>>>>>> source other than "yourself" as grounds for me being wrong.
>>>>>>
>>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>>
>>>>>> Note, I DON'T change the subject, I go to the core of what you are
>>>>>> talking about, and you object to that as I don't let you build up
>>>>>> a bed of half truths to try to make you ideas seem possibly
>>>>>> plausable.
>>>>>>
>>>>>> Unless you ADMIT that you aren't talking about the Halting Theorm,
>>>>>> all my comments are "On Topic" as I am just pointing out the basic
>>>>>> definitions of the theory.
>>>>>>
>>>>>> YOU are the one that changes the subject.
>>>>>>
>>>>>> YOU FAIL.
>>>>>
>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>> The correct and complete simulation of a machine description always
>>>>> provides the actual behavior specified by this machine description.
>>>>
>>>> Correct, and the machine description includes ALL the code executed
>>>> by the program, including all subroutines/function it calls.
>>>>
>>>>>
>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>> When-so-ever a simulating halt decider (SHD) correctly performs a
>>>>> partial simulation of its input and the behavior of this partial
>>>>> simulation correctly matches a correct non-halting behavior pattern
>>>>> then the SHD halt decider can correctly report non-halting.
>>>>
>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>
>>>>>
>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>> A non-halting behavior pattern is correct when-so-ever matching
>>>>> this behavior pattern proves that the simulated input to the SHD
>>>>> would never stop running unless the SHD aborted its simulation.
>>>>>
>>>>
>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>
>>>> A non-halting behavior pattern is a pattern that means that a
>>>> correct and complete simulation could never stop after seeing that
>>>> pattern, in any machine.
>>>>
>>>
>>> No it doesn't mean anything like that.
>>
>> You have a reference for that, or are you going to just use incorrect
>> logic to try to make your point.
>>
>>>
>>> Example 01:
>>> H0 correctly determines that Infinite_Loop() never halts
>>>
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>> }
>>>
>>> _Infinite_Loop()
>>> [00001102](01)  55         push ebp
>>> [00001103](02)  8bec       mov ebp,esp
>>> [00001105](02)  ebfe       jmp 00001105
>>> [00001107](01)  5d         pop ebp
>>> [00001108](01)  c3         ret
>>> Size in bytes:(0007) [00001108]
>>>
>>> _main()
>>> [00001192](01)  55         push ebp
>>> [00001193](02)  8bec       mov ebp,esp
>>> [00001195](05)  6802110000 push 00001102
>>> [0000119a](05)  e8d3fbffff call 00000d72
>>> [0000119f](03)  83c404     add esp,+04
>>> [000011a2](01)  50         push eax
>>> [000011a3](05)  68a3040000 push 000004a3
>>> [000011a8](05)  e845f3ffff call 000004f2
>>> [000011ad](03)  83c408     add esp,+08
>>> [000011b0](02)  33c0       xor eax,eax
>>> [000011b2](01)  5d         pop ebp
>>> [000011b3](01)  c3         ret
>>> Size in bytes:(0034) [000011b3]
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [00001192][00101ef8][00000000] 55         push ebp
>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>
>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>> H0: Infinite Loop Detected Simulation Stopped
>>>
>>>   if (current->Simplified_Opcode == JMP)           // JMP
>>>    if (current->Decode_Target <= current->Address) // upward
>>>     if (traced->Address == current->Decode_Target) // to this address
>>>      if (Conditional_Branch_Count == 0)            // no escape
>>>       return 1;
>>>
>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>> [000011a2][00101ef4][00000000] 50         push eax
>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>> Input_Halts = 0
>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>> [000011b3][00101f00][00000004] c3         ret
>>> Number of Instructions Executed(554) == 8 Pages
>>>
>>>> Halting is a property of the MACHINE, that is the MACHINE the input
>>>> specified.
>>>
>>> If halt deciders examined machines you would be correct.
>>> Halt deciders never examine machines.
>>> Halt deciders always examine finite string machine descriptions.
>>
>> Isn't the finite string the machine code?
>>
>> I thought you defined your "finite string" to BE the machine code for
>> your machine.
>>
>>
>>>
>>> Because a simulating halt decider is a pure simulator that has extra
>>> features added to it a simulating halt decider that never aborts its
>>> simulation is simply a pure simulator thus
>>
>> So does your H abort its simulation or not.
>>
>> If it doesn't, then YES, it does a pure simulation and thus doesn't
>> stop until the input reaches a final state, and thus never answers for
>> a non-halting input, or
>>
>> if it DOES, then it can't be the source of what a pure simulator does,
>> since it isn't one.
>>
>> Pleae show me a program that does BOTH be a pure simulator that
>> simulates the non-halting input until it (never) reaches the final
>> state, and also aborts its simulation to return the non-halting
>> answer, at the same time.
>>
>>
>>
>>>
>>> A non-halting behavior pattern is correct when-so-ever matching this
>>> behavior pattern proves that the simulated input to the SHD would
>>> never stop running unless the SHD aborted its simulation.
>>>
>>
>> Nope. Proven wrong and illogical. You can't ask about behavior of a
>> program (the SHD) that isn't part of the system. The "non-aborting"
>> SHD is NOT the SHD, so you condition just doesn't occur.
>
> A simulating halt decider
> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT WOULD BE IF IT NEVER
> ABORTED THE SIMULATION OF THIS INPUT
>


Click here to read the complete article
Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]

<jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 21:06:36 +0000
Date: Sat, 27 Aug 2022 16:06:35 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<RYydnfb_zOIJ_JT-nZ2dnZfqlJzNnZ2d@giganews.com>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<zzuOK.876382$ntj.37244@fx15.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <zzuOK.876382$ntj.37244@fx15.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 259
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-kvp8Yhi5J05BOSwCdL6qKANVlMlSI2QumfnQgQf0Dd5iN6ZJvZQJ8neZ1uXOzhnJlFKGyl2f1OoxmBK!oABTXX1R1Nvmsss+bM8/sVztsy01+VRpOlf43zR/V+dfpWdyS9dKCpZYkNTg9+xa5MN41tM/kcE=
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
 by: olcott - Sat, 27 Aug 2022 21:06 UTC

On 8/27/2022 2:49 PM, Richard Damon wrote:
>
> On 8/27/22 3:32 PM, olcott wrote:
>> On 8/27/2022 2:21 PM, Richard Damon wrote:
>>> On 8/27/22 2:57 PM, olcott wrote:
>>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>>
>>>>>>>>>>>>> Or just caught wordless because you are seeing you have no
>>>>>>>>>>>>> answer?
>>>>>>>>>>>>
>>>>>>>>>>>> He is just replying to change the subject line to call you a
>>>>>>>>>>>> troll and
>>>>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>>>>> really is a
>>>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> True.
>>>>>>>>>>>
>>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>>
>>>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>>>> statements he is admitting that he is wrong, but won't actually
>>>>>>>>> admit it.
>>>>>>>>>
>>>>>>>>> By ignoring the people pointing out errors, he shows that he is
>>>>>>>>> only interested in himself and not what is actually true.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I have pointed out all of the errors of all of your rebuttals
>>>>>>>> and instead of addressing these errors you change the subject
>>>>>>>> only to get back to make these same mistakes again and again.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Really, point to an error I have made that you pointed out to any
>>>>>>> source other than "yourself" as grounds for me being wrong.
>>>>>>>
>>>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>>>
>>>>>>> Note, I DON'T change the subject, I go to the core of what you
>>>>>>> are talking about, and you object to that as I don't let you
>>>>>>> build up a bed of half truths to try to make you ideas seem
>>>>>>> possibly plausable.
>>>>>>>
>>>>>>> Unless you ADMIT that you aren't talking about the Halting
>>>>>>> Theorm, all my comments are "On Topic" as I am just pointing out
>>>>>>> the basic definitions of the theory.
>>>>>>>
>>>>>>> YOU are the one that changes the subject.
>>>>>>>
>>>>>>> YOU FAIL.
>>>>>>
>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>> The correct and complete simulation of a machine description
>>>>>> always provides the actual behavior specified by this machine
>>>>>> description.
>>>>>
>>>>> Correct, and the machine description includes ALL the code executed
>>>>> by the program, including all subroutines/function it calls.
>>>>>
>>>>>>
>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>> When-so-ever a simulating halt decider (SHD) correctly performs a
>>>>>> partial simulation of its input and the behavior of this partial
>>>>>> simulation correctly matches a correct non-halting behavior
>>>>>> pattern then the SHD halt decider can correctly report non-halting.
>>>>>
>>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>>
>>>>>>
>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>> A non-halting behavior pattern is correct when-so-ever matching
>>>>>> this behavior pattern proves that the simulated input to the SHD
>>>>>> would never stop running unless the SHD aborted its simulation.
>>>>>>
>>>>>
>>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>>
>>>>> A non-halting behavior pattern is a pattern that means that a
>>>>> correct and complete simulation could never stop after seeing that
>>>>> pattern, in any machine.
>>>>>
>>>>
>>>> No it doesn't mean anything like that.
>>>
>>> You have a reference for that, or are you going to just use incorrect
>>> logic to try to make your point.
>>>
>>>>
>>>> Example 01:
>>>> H0 correctly determines that Infinite_Loop() never halts
>>>>
>>>> void Infinite_Loop()
>>>> {
>>>>    HERE: goto HERE;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>> }
>>>>
>>>> _Infinite_Loop()
>>>> [00001102](01)  55         push ebp
>>>> [00001103](02)  8bec       mov ebp,esp
>>>> [00001105](02)  ebfe       jmp 00001105
>>>> [00001107](01)  5d         pop ebp
>>>> [00001108](01)  c3         ret
>>>> Size in bytes:(0007) [00001108]
>>>>
>>>> _main()
>>>> [00001192](01)  55         push ebp
>>>> [00001193](02)  8bec       mov ebp,esp
>>>> [00001195](05)  6802110000 push 00001102
>>>> [0000119a](05)  e8d3fbffff call 00000d72
>>>> [0000119f](03)  83c404     add esp,+04
>>>> [000011a2](01)  50         push eax
>>>> [000011a3](05)  68a3040000 push 000004a3
>>>> [000011a8](05)  e845f3ffff call 000004f2
>>>> [000011ad](03)  83c408     add esp,+08
>>>> [000011b0](02)  33c0       xor eax,eax
>>>> [000011b2](01)  5d         pop ebp
>>>> [000011b3](01)  c3         ret
>>>> Size in bytes:(0034) [000011b3]
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001192][00101ef8][00000000] 55         push ebp
>>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>>
>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>
>>>>   if (current->Simplified_Opcode == JMP)           // JMP
>>>>    if (current->Decode_Target <= current->Address) // upward
>>>>     if (traced->Address == current->Decode_Target) // to this address
>>>>      if (Conditional_Branch_Count == 0)            // no escape
>>>>       return 1;
>>>>
>>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>>> [000011a2][00101ef4][00000000] 50         push eax
>>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>>> Input_Halts = 0
>>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>>> [000011b3][00101f00][00000004] c3         ret
>>>> Number of Instructions Executed(554) == 8 Pages
>>>>
>>>>> Halting is a property of the MACHINE, that is the MACHINE the input
>>>>> specified.
>>>>
>>>> If halt deciders examined machines you would be correct.
>>>> Halt deciders never examine machines.
>>>> Halt deciders always examine finite string machine descriptions.
>>>
>>> Isn't the finite string the machine code?
>>>
>>> I thought you defined your "finite string" to BE the machine code for
>>> your machine.
>>>
>>>
>>>>
>>>> Because a simulating halt decider is a pure simulator that has extra
>>>> features added to it a simulating halt decider that never aborts its
>>>> simulation is simply a pure simulator thus
>>>
>>> So does your H abort its simulation or not.
>>>
>>> If it doesn't, then YES, it does a pure simulation and thus doesn't
>>> stop until the input reaches a final state, and thus never answers
>>> for a non-halting input, or
>>>
>>> if it DOES, then it can't be the source of what a pure simulator
>>> does, since it isn't one.
>>>
>>> Pleae show me a program that does BOTH be a pure simulator that
>>> simulates the non-halting input until it (never) reaches the final
>>> state, and also aborts its simulation to return the non-halting
>>> answer, at the same time.
>>>
>>>
>>>
>>>>
>>>> A non-halting behavior pattern is correct when-so-ever matching this
>>>> behavior pattern proves that the simulated input to the SHD would
>>>> never stop running unless the SHD aborted its simulation.
>>>>
>>>
>>> Nope. Proven wrong and illogical. You can't ask about behavior of a
>>> program (the SHD) that isn't part of the system. The "non-aborting"
>>> SHD is NOT the SHD, so you condition just doesn't occur.
>>
>> A simulating halt decider
>> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT WOULD BE IF IT NEVER
>> ABORTED THE SIMULATION OF THIS INPUT
>>
>
> Then it isn't a Halt Decider. PERIOD.
>
> A REAL Halt Decider decides on the behavior of the machine represented
> by its input, not the behavior of itself.
*Ah so that was my best wording*


Click here to read the complete article
Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]

<tSvOK.125829$Ae2.104988@fx35.iad>

  copy mid

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

  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!fx35.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.13.0
Subject: Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<20220827120807.000078f7@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<zzuOK.876382$ntj.37244@fx15.iad>
<jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 274
Message-ID: <tSvOK.125829$Ae2.104988@fx35.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, 27 Aug 2022 17:18:16 -0400
X-Received-Bytes: 13039
 by: Richard Damon - Sat, 27 Aug 2022 21:18 UTC

On 8/27/22 5:06 PM, olcott wrote:
> On 8/27/2022 2:49 PM, Richard Damon wrote:
>>
>> On 8/27/22 3:32 PM, olcott wrote:
>>> On 8/27/2022 2:21 PM, Richard Damon wrote:
>>>> On 8/27/22 2:57 PM, olcott wrote:
>>>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Or just caught wordless because you are seeing you have no
>>>>>>>>>>>>>> answer?
>>>>>>>>>>>>>
>>>>>>>>>>>>> He is just replying to change the subject line to call you
>>>>>>>>>>>>> a troll and
>>>>>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>>>>>> really is a
>>>>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> True.
>>>>>>>>>>>>
>>>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>>>
>>>>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>>>>> statements he is admitting that he is wrong, but won't
>>>>>>>>>> actually admit it.
>>>>>>>>>>
>>>>>>>>>> By ignoring the people pointing out errors, he shows that he
>>>>>>>>>> is only interested in himself and not what is actually true.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I have pointed out all of the errors of all of your rebuttals
>>>>>>>>> and instead of addressing these errors you change the subject
>>>>>>>>> only to get back to make these same mistakes again and again.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> Really, point to an error I have made that you pointed out to
>>>>>>>> any source other than "yourself" as grounds for me being wrong.
>>>>>>>>
>>>>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>>>>
>>>>>>>> Note, I DON'T change the subject, I go to the core of what you
>>>>>>>> are talking about, and you object to that as I don't let you
>>>>>>>> build up a bed of half truths to try to make you ideas seem
>>>>>>>> possibly plausable.
>>>>>>>>
>>>>>>>> Unless you ADMIT that you aren't talking about the Halting
>>>>>>>> Theorm, all my comments are "On Topic" as I am just pointing out
>>>>>>>> the basic definitions of the theory.
>>>>>>>>
>>>>>>>> YOU are the one that changes the subject.
>>>>>>>>
>>>>>>>> YOU FAIL.
>>>>>>>
>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>> The correct and complete simulation of a machine description
>>>>>>> always provides the actual behavior specified by this machine
>>>>>>> description.
>>>>>>
>>>>>> Correct, and the machine description includes ALL the code
>>>>>> executed by the program, including all subroutines/function it calls.
>>>>>>
>>>>>>>
>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>> When-so-ever a simulating halt decider (SHD) correctly performs a
>>>>>>> partial simulation of its input and the behavior of this partial
>>>>>>> simulation correctly matches a correct non-halting behavior
>>>>>>> pattern then the SHD halt decider can correctly report non-halting.
>>>>>>
>>>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>>>
>>>>>>>
>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>> A non-halting behavior pattern is correct when-so-ever matching
>>>>>>> this behavior pattern proves that the simulated input to the SHD
>>>>>>> would never stop running unless the SHD aborted its simulation.
>>>>>>>
>>>>>>
>>>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>>>
>>>>>> A non-halting behavior pattern is a pattern that means that a
>>>>>> correct and complete simulation could never stop after seeing that
>>>>>> pattern, in any machine.
>>>>>>
>>>>>
>>>>> No it doesn't mean anything like that.
>>>>
>>>> You have a reference for that, or are you going to just use
>>>> incorrect logic to try to make your point.
>>>>
>>>>>
>>>>> Example 01:
>>>>> H0 correctly determines that Infinite_Loop() never halts
>>>>>
>>>>> void Infinite_Loop()
>>>>> {
>>>>>    HERE: goto HERE;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>> }
>>>>>
>>>>> _Infinite_Loop()
>>>>> [00001102](01)  55         push ebp
>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>> [00001107](01)  5d         pop ebp
>>>>> [00001108](01)  c3         ret
>>>>> Size in bytes:(0007) [00001108]
>>>>>
>>>>> _main()
>>>>> [00001192](01)  55         push ebp
>>>>> [00001193](02)  8bec       mov ebp,esp
>>>>> [00001195](05)  6802110000 push 00001102
>>>>> [0000119a](05)  e8d3fbffff call 00000d72
>>>>> [0000119f](03)  83c404     add esp,+04
>>>>> [000011a2](01)  50         push eax
>>>>> [000011a3](05)  68a3040000 push 000004a3
>>>>> [000011a8](05)  e845f3ffff call 000004f2
>>>>> [000011ad](03)  83c408     add esp,+08
>>>>> [000011b0](02)  33c0       xor eax,eax
>>>>> [000011b2](01)  5d         pop ebp
>>>>> [000011b3](01)  c3         ret
>>>>> Size in bytes:(0034) [000011b3]
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001192][00101ef8][00000000] 55         push ebp
>>>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>>>
>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>
>>>>>   if (current->Simplified_Opcode == JMP)           // JMP
>>>>>    if (current->Decode_Target <= current->Address) // upward
>>>>>     if (traced->Address == current->Decode_Target) // to this address
>>>>>      if (Conditional_Branch_Count == 0)            // no escape
>>>>>       return 1;
>>>>>
>>>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>>>> [000011a2][00101ef4][00000000] 50         push eax
>>>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>>>> Input_Halts = 0
>>>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>>>> [000011b3][00101f00][00000004] c3         ret
>>>>> Number of Instructions Executed(554) == 8 Pages
>>>>>
>>>>>> Halting is a property of the MACHINE, that is the MACHINE the
>>>>>> input specified.
>>>>>
>>>>> If halt deciders examined machines you would be correct.
>>>>> Halt deciders never examine machines.
>>>>> Halt deciders always examine finite string machine descriptions.
>>>>
>>>> Isn't the finite string the machine code?
>>>>
>>>> I thought you defined your "finite string" to BE the machine code
>>>> for your machine.
>>>>
>>>>
>>>>>
>>>>> Because a simulating halt decider is a pure simulator that has
>>>>> extra features added to it a simulating halt decider that never
>>>>> aborts its simulation is simply a pure simulator thus
>>>>
>>>> So does your H abort its simulation or not.
>>>>
>>>> If it doesn't, then YES, it does a pure simulation and thus doesn't
>>>> stop until the input reaches a final state, and thus never answers
>>>> for a non-halting input, or
>>>>
>>>> if it DOES, then it can't be the source of what a pure simulator
>>>> does, since it isn't one.
>>>>
>>>> Pleae show me a program that does BOTH be a pure simulator that
>>>> simulates the non-halting input until it (never) reaches the final
>>>> state, and also aborts its simulation to return the non-halting
>>>> answer, at the same time.
>>>>
>>>>
>>>>
>>>>>
>>>>> A non-halting behavior pattern is correct when-so-ever matching this
>>>>> behavior pattern proves that the simulated input to the SHD would
>>>>> never stop running unless the SHD aborted its simulation.
>>>>>
>>>>
>>>> Nope. Proven wrong and illogical. You can't ask about behavior of a
>>>> program (the SHD) that isn't part of the system. The "non-aborting"
>>>> SHD is NOT the SHD, so you condition just doesn't occur.
>>>
>>> A simulating halt decider
>>> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT WOULD BE IF IT
>>> NEVER ABORTED THE SIMULATION OF THIS INPUT
>>>
>>
>> Then it isn't a Halt Decider. PERIOD.
>>
>> A REAL Halt Decider decides on the behavior of the machine represented
>> by its input, not the behavior of itself.
> *Ah so that was my best wording*
>
> (a) Every decider must compute the mapping from its input finite string
> based on a semantic or syntactic property of this finite string.


Click here to read the complete article
Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]

<qKKcnaG4BIBnEJf-nZ2dnZfqlJ_NnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-1.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 21:34:50 +0000
Date: Sat, 27 Aug 2022 16:34:49 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<EOmdnQXxqe0os5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<zzuOK.876382$ntj.37244@fx15.iad>
<jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>
<tSvOK.125829$Ae2.104988@fx35.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <tSvOK.125829$Ae2.104988@fx35.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <qKKcnaG4BIBnEJf-nZ2dnZfqlJ_NnZ2d@giganews.com>
Lines: 291
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-GF8fMllB4Fe/lfkvoGoTFP00ADxY0u5k28AWf1FzwfnJt9fzKq9eeDPNBsF3t8U1bynqY9er0Q/tFAE!8Uva0bU0Ba0kaE5TxLDHy+G5MWwDpDoFbuv3bi7jdlPir2KqpD9B4G6YgNZlJ8jOeqY6RIuThaQ=
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
 by: olcott - Sat, 27 Aug 2022 21:34 UTC

On 8/27/2022 4:18 PM, Richard Damon wrote:
> On 8/27/22 5:06 PM, olcott wrote:
>> On 8/27/2022 2:49 PM, Richard Damon wrote:
>>>
>>> On 8/27/22 3:32 PM, olcott wrote:
>>>> On 8/27/2022 2:21 PM, Richard Damon wrote:
>>>>> On 8/27/22 2:57 PM, olcott wrote:
>>>>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Or just caught wordless because you are seeing you have
>>>>>>>>>>>>>>> no answer?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> He is just replying to change the subject line to call you
>>>>>>>>>>>>>> a troll and
>>>>>>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>>>>>>> really is a
>>>>>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> True.
>>>>>>>>>>>>>
>>>>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>>>>
>>>>>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying Idiot
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>>>>>> statements he is admitting that he is wrong, but won't
>>>>>>>>>>> actually admit it.
>>>>>>>>>>>
>>>>>>>>>>> By ignoring the people pointing out errors, he shows that he
>>>>>>>>>>> is only interested in himself and not what is actually true.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I have pointed out all of the errors of all of your rebuttals
>>>>>>>>>> and instead of addressing these errors you change the subject
>>>>>>>>>> only to get back to make these same mistakes again and again.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Really, point to an error I have made that you pointed out to
>>>>>>>>> any source other than "yourself" as grounds for me being wrong.
>>>>>>>>>
>>>>>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>>>>>
>>>>>>>>> Note, I DON'T change the subject, I go to the core of what you
>>>>>>>>> are talking about, and you object to that as I don't let you
>>>>>>>>> build up a bed of half truths to try to make you ideas seem
>>>>>>>>> possibly plausable.
>>>>>>>>>
>>>>>>>>> Unless you ADMIT that you aren't talking about the Halting
>>>>>>>>> Theorm, all my comments are "On Topic" as I am just pointing
>>>>>>>>> out the basic definitions of the theory.
>>>>>>>>>
>>>>>>>>> YOU are the one that changes the subject.
>>>>>>>>>
>>>>>>>>> YOU FAIL.
>>>>>>>>
>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>> The correct and complete simulation of a machine description
>>>>>>>> always provides the actual behavior specified by this machine
>>>>>>>> description.
>>>>>>>
>>>>>>> Correct, and the machine description includes ALL the code
>>>>>>> executed by the program, including all subroutines/function it
>>>>>>> calls.
>>>>>>>
>>>>>>>>
>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly performs
>>>>>>>> a partial simulation of its input and the behavior of this
>>>>>>>> partial simulation correctly matches a correct non-halting
>>>>>>>> behavior pattern then the SHD halt decider can correctly report
>>>>>>>> non-halting.
>>>>>>>
>>>>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>>>>
>>>>>>>>
>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>> A non-halting behavior pattern is correct when-so-ever matching
>>>>>>>> this behavior pattern proves that the simulated input to the SHD
>>>>>>>> would never stop running unless the SHD aborted its simulation.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>>>>
>>>>>>> A non-halting behavior pattern is a pattern that means that a
>>>>>>> correct and complete simulation could never stop after seeing
>>>>>>> that pattern, in any machine.
>>>>>>>
>>>>>>
>>>>>> No it doesn't mean anything like that.
>>>>>
>>>>> You have a reference for that, or are you going to just use
>>>>> incorrect logic to try to make your point.
>>>>>
>>>>>>
>>>>>> Example 01:
>>>>>> H0 correctly determines that Infinite_Loop() never halts
>>>>>>
>>>>>> void Infinite_Loop()
>>>>>> {
>>>>>>    HERE: goto HERE;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>> }
>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00001102](01)  55         push ebp
>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>> [00001107](01)  5d         pop ebp
>>>>>> [00001108](01)  c3         ret
>>>>>> Size in bytes:(0007) [00001108]
>>>>>>
>>>>>> _main()
>>>>>> [00001192](01)  55         push ebp
>>>>>> [00001193](02)  8bec       mov ebp,esp
>>>>>> [00001195](05)  6802110000 push 00001102
>>>>>> [0000119a](05)  e8d3fbffff call 00000d72
>>>>>> [0000119f](03)  83c404     add esp,+04
>>>>>> [000011a2](01)  50         push eax
>>>>>> [000011a3](05)  68a3040000 push 000004a3
>>>>>> [000011a8](05)  e845f3ffff call 000004f2
>>>>>> [000011ad](03)  83c408     add esp,+08
>>>>>> [000011b0](02)  33c0       xor eax,eax
>>>>>> [000011b2](01)  5d         pop ebp
>>>>>> [000011b3](01)  c3         ret
>>>>>> Size in bytes:(0034) [000011b3]
>>>>>>
>>>>>>   machine   stack     stack     machine    assembly
>>>>>>   address   address   data      code       language
>>>>>>   ========  ========  ========  =========  =============
>>>>>> [00001192][00101ef8][00000000] 55         push ebp
>>>>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>>>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>>>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>>>>
>>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>
>>>>>>   if (current->Simplified_Opcode == JMP)           // JMP
>>>>>>    if (current->Decode_Target <= current->Address) // upward
>>>>>>     if (traced->Address == current->Decode_Target) // to this address
>>>>>>      if (Conditional_Branch_Count == 0)            // no escape
>>>>>>       return 1;
>>>>>>
>>>>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>>>>> [000011a2][00101ef4][00000000] 50         push eax
>>>>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>>>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>>>>> Input_Halts = 0
>>>>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>>>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>>>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>>>>> [000011b3][00101f00][00000004] c3         ret
>>>>>> Number of Instructions Executed(554) == 8 Pages
>>>>>>
>>>>>>> Halting is a property of the MACHINE, that is the MACHINE the
>>>>>>> input specified.
>>>>>>
>>>>>> If halt deciders examined machines you would be correct.
>>>>>> Halt deciders never examine machines.
>>>>>> Halt deciders always examine finite string machine descriptions.
>>>>>
>>>>> Isn't the finite string the machine code?
>>>>>
>>>>> I thought you defined your "finite string" to BE the machine code
>>>>> for your machine.
>>>>>
>>>>>
>>>>>>
>>>>>> Because a simulating halt decider is a pure simulator that has
>>>>>> extra features added to it a simulating halt decider that never
>>>>>> aborts its simulation is simply a pure simulator thus
>>>>>
>>>>> So does your H abort its simulation or not.
>>>>>
>>>>> If it doesn't, then YES, it does a pure simulation and thus doesn't
>>>>> stop until the input reaches a final state, and thus never answers
>>>>> for a non-halting input, or
>>>>>
>>>>> if it DOES, then it can't be the source of what a pure simulator
>>>>> does, since it isn't one.
>>>>>
>>>>> Pleae show me a program that does BOTH be a pure simulator that
>>>>> simulates the non-halting input until it (never) reaches the final
>>>>> state, and also aborts its simulation to return the non-halting
>>>>> answer, at the same time.
>>>>>
>>>>>
>>>>>
>>>>>>
>>>>>> A non-halting behavior pattern is correct when-so-ever matching this
>>>>>> behavior pattern proves that the simulated input to the SHD would
>>>>>> never stop running unless the SHD aborted its simulation.
>>>>>>
>>>>>
>>>>> Nope. Proven wrong and illogical. You can't ask about behavior of a
>>>>> program (the SHD) that isn't part of the system. The "non-aborting"
>>>>> SHD is NOT the SHD, so you condition just doesn't occur.
>>>>
>>>> A simulating halt decider
>>>> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT WOULD BE IF IT
>>>> NEVER ABORTED THE SIMULATION OF THIS INPUT
>>>>
>>>
>>> Then it isn't a Halt Decider. PERIOD.
>>>
>>> A REAL Halt Decider decides on the behavior of the machine
>>> represented by its input, not the behavior of itself.
>> *Ah so that was my best wording*
>>
>> (a) Every decider must compute the mapping from its input finite
>> string based on a semantic or syntactic property of this finite string.
>
> Right, and the propert of this finite string is the behavior of UTM(P,d)
>


Click here to read the complete article
Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]

<IqwOK.172003$ze2.53966@fx36.iad>

  copy mid

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

  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!fx36.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.13.0
Subject: Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<zzuOK.876382$ntj.37244@fx15.iad>
<jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>
<tSvOK.125829$Ae2.104988@fx35.iad>
<qKKcnaG4BIBnEJf-nZ2dnZfqlJ_NnZ2d@giganews.com>
From: Rich...@Damon-Family.org (Richard Damon)
In-Reply-To: <qKKcnaG4BIBnEJf-nZ2dnZfqlJ_NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Lines: 342
Message-ID: <IqwOK.172003$ze2.53966@fx36.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, 27 Aug 2022 17:56:55 -0400
X-Received-Bytes: 15248
 by: Richard Damon - Sat, 27 Aug 2022 21:56 UTC

On 8/27/22 5:34 PM, olcott wrote:
> On 8/27/2022 4:18 PM, Richard Damon wrote:
>> On 8/27/22 5:06 PM, olcott wrote:
>>> On 8/27/2022 2:49 PM, Richard Damon wrote:
>>>>
>>>> On 8/27/22 3:32 PM, olcott wrote:
>>>>> On 8/27/2022 2:21 PM, Richard Damon wrote:
>>>>>> On 8/27/22 2:57 PM, olcott wrote:
>>>>>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Or just caught wordless because you are seeing you have
>>>>>>>>>>>>>>>> no answer?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> He is just replying to change the subject line to call
>>>>>>>>>>>>>>> you a troll and
>>>>>>>>>>>>>>> to say that I am clueless about software engineering.  He
>>>>>>>>>>>>>>> really is a
>>>>>>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> True.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying
>>>>>>>>>>>>>> Idiot
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>>>>>>> statements he is admitting that he is wrong, but won't
>>>>>>>>>>>> actually admit it.
>>>>>>>>>>>>
>>>>>>>>>>>> By ignoring the people pointing out errors, he shows that he
>>>>>>>>>>>> is only interested in himself and not what is actually true.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I have pointed out all of the errors of all of your rebuttals
>>>>>>>>>>> and instead of addressing these errors you change the subject
>>>>>>>>>>> only to get back to make these same mistakes again and again.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Really, point to an error I have made that you pointed out to
>>>>>>>>>> any source other than "yourself" as grounds for me being wrong.
>>>>>>>>>>
>>>>>>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>>>>>>
>>>>>>>>>> Note, I DON'T change the subject, I go to the core of what you
>>>>>>>>>> are talking about, and you object to that as I don't let you
>>>>>>>>>> build up a bed of half truths to try to make you ideas seem
>>>>>>>>>> possibly plausable.
>>>>>>>>>>
>>>>>>>>>> Unless you ADMIT that you aren't talking about the Halting
>>>>>>>>>> Theorm, all my comments are "On Topic" as I am just pointing
>>>>>>>>>> out the basic definitions of the theory.
>>>>>>>>>>
>>>>>>>>>> YOU are the one that changes the subject.
>>>>>>>>>>
>>>>>>>>>> YOU FAIL.
>>>>>>>>>
>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>> The correct and complete simulation of a machine description
>>>>>>>>> always provides the actual behavior specified by this machine
>>>>>>>>> description.
>>>>>>>>
>>>>>>>> Correct, and the machine description includes ALL the code
>>>>>>>> executed by the program, including all subroutines/function it
>>>>>>>> calls.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly performs
>>>>>>>>> a partial simulation of its input and the behavior of this
>>>>>>>>> partial simulation correctly matches a correct non-halting
>>>>>>>>> behavior pattern then the SHD halt decider can correctly report
>>>>>>>>> non-halting.
>>>>>>>>
>>>>>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>> A non-halting behavior pattern is correct when-so-ever matching
>>>>>>>>> this behavior pattern proves that the simulated input to the
>>>>>>>>> SHD would never stop running unless the SHD aborted its
>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>>>>>
>>>>>>>> A non-halting behavior pattern is a pattern that means that a
>>>>>>>> correct and complete simulation could never stop after seeing
>>>>>>>> that pattern, in any machine.
>>>>>>>>
>>>>>>>
>>>>>>> No it doesn't mean anything like that.
>>>>>>
>>>>>> You have a reference for that, or are you going to just use
>>>>>> incorrect logic to try to make your point.
>>>>>>
>>>>>>>
>>>>>>> Example 01:
>>>>>>> H0 correctly determines that Infinite_Loop() never halts
>>>>>>>
>>>>>>> void Infinite_Loop()
>>>>>>> {
>>>>>>>    HERE: goto HERE;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>> }
>>>>>>>
>>>>>>> _Infinite_Loop()
>>>>>>> [00001102](01)  55         push ebp
>>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>>> [00001107](01)  5d         pop ebp
>>>>>>> [00001108](01)  c3         ret
>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>
>>>>>>> _main()
>>>>>>> [00001192](01)  55         push ebp
>>>>>>> [00001193](02)  8bec       mov ebp,esp
>>>>>>> [00001195](05)  6802110000 push 00001102
>>>>>>> [0000119a](05)  e8d3fbffff call 00000d72
>>>>>>> [0000119f](03)  83c404     add esp,+04
>>>>>>> [000011a2](01)  50         push eax
>>>>>>> [000011a3](05)  68a3040000 push 000004a3
>>>>>>> [000011a8](05)  e845f3ffff call 000004f2
>>>>>>> [000011ad](03)  83c408     add esp,+08
>>>>>>> [000011b0](02)  33c0       xor eax,eax
>>>>>>> [000011b2](01)  5d         pop ebp
>>>>>>> [000011b3](01)  c3         ret
>>>>>>> Size in bytes:(0034) [000011b3]
>>>>>>>
>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>   address   address   data      code       language
>>>>>>>   ========  ========  ========  =========  =============
>>>>>>> [00001192][00101ef8][00000000] 55         push ebp
>>>>>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>>>>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>>>>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>>>>>
>>>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>
>>>>>>>   if (current->Simplified_Opcode == JMP)           // JMP
>>>>>>>    if (current->Decode_Target <= current->Address) // upward
>>>>>>>     if (traced->Address == current->Decode_Target) // to this
>>>>>>> address
>>>>>>>      if (Conditional_Branch_Count == 0)            // no escape
>>>>>>>       return 1;
>>>>>>>
>>>>>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>>>>>> [000011a2][00101ef4][00000000] 50         push eax
>>>>>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>>>>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>>>>>> Input_Halts = 0
>>>>>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>>>>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>>>>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>>>>>> [000011b3][00101f00][00000004] c3         ret
>>>>>>> Number of Instructions Executed(554) == 8 Pages
>>>>>>>
>>>>>>>> Halting is a property of the MACHINE, that is the MACHINE the
>>>>>>>> input specified.
>>>>>>>
>>>>>>> If halt deciders examined machines you would be correct.
>>>>>>> Halt deciders never examine machines.
>>>>>>> Halt deciders always examine finite string machine descriptions.
>>>>>>
>>>>>> Isn't the finite string the machine code?
>>>>>>
>>>>>> I thought you defined your "finite string" to BE the machine code
>>>>>> for your machine.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> Because a simulating halt decider is a pure simulator that has
>>>>>>> extra features added to it a simulating halt decider that never
>>>>>>> aborts its simulation is simply a pure simulator thus
>>>>>>
>>>>>> So does your H abort its simulation or not.
>>>>>>
>>>>>> If it doesn't, then YES, it does a pure simulation and thus
>>>>>> doesn't stop until the input reaches a final state, and thus never
>>>>>> answers for a non-halting input, or
>>>>>>
>>>>>> if it DOES, then it can't be the source of what a pure simulator
>>>>>> does, since it isn't one.
>>>>>>
>>>>>> Pleae show me a program that does BOTH be a pure simulator that
>>>>>> simulates the non-halting input until it (never) reaches the final
>>>>>> state, and also aborts its simulation to return the non-halting
>>>>>> answer, at the same time.
>>>>>>
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> A non-halting behavior pattern is correct when-so-ever matching this
>>>>>>> behavior pattern proves that the simulated input to the SHD would
>>>>>>> never stop running unless the SHD aborted its simulation.
>>>>>>>
>>>>>>
>>>>>> Nope. Proven wrong and illogical. You can't ask about behavior of
>>>>>> a program (the SHD) that isn't part of the system. The
>>>>>> "non-aborting" SHD is NOT the SHD, so you condition just doesn't
>>>>>> occur.
>>>>>
>>>>> A simulating halt decider
>>>>> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT WOULD BE IF IT
>>>>> NEVER ABORTED THE SIMULATION OF THIS INPUT
>>>>>
>>>>
>>>> Then it isn't a Halt Decider. PERIOD.
>>>>
>>>> A REAL Halt Decider decides on the behavior of the machine
>>>> represented by its input, not the behavior of itself.
>>> *Ah so that was my best wording*
>>>
>>> (a) Every decider must compute the mapping from its input finite
>>> string based on a semantic or syntactic property of this finite string.
>>
>> Right, and the propert of this finite string is the behavior of UTM(P,d)
>>
>
> No not at all. The decider could be determining whether or not an input
> string contains: "A".


Click here to read the complete article
Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]

<CPOdnW8yhYxKBJf-nZ2dnZfqlJzNnZ2d@giganews.com>

  copy mid

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

  copy link   Newsgroups: comp.theory
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border-2.nntp.ord.giganews.com!border-1.nntp.ord.giganews.com!nntp.giganews.com!Xl.tags.giganews.com!local-2.nntp.ord.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Sat, 27 Aug 2022 22:25:27 +0000
Date: Sat, 27 Aug 2022 17:25:26 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.13.0
Subject: Re: Olcott is a Troll [ fake rebuttal to all of Richards rebuttals ]
Content-Language: en-US
Newsgroups: comp.theory
References: <20220817174635.00004410@reddwarf.jmc.corp>
<IgqOK.883609$70j.372919@fx16.iad>
<Scednc9TAcDLr5f-nZ2dnZfqlJxh4p2d@giganews.com>
<luqOK.839174$J0r9.207864@fx11.iad>
<iAGdnfUhWtrqqpf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<ZXqOK.782930$5fVf.780439@fx09.iad>
<_oqdnaum358L0Zf-nZ2dnZfqlJzNnZ2d@giganews.com>
<F6sOK.841862$J0r9.210570@fx11.iad>
<20220827180455.00006e13@reddwarf.jmc.corp> <_usOK.169547$nZ1.79892@fx05.iad>
<6NqdnetSWMy6yJf-nZ2dnZfqlJzNnZ2d@giganews.com>
<dGsOK.889035$ssF.324130@fx14.iad>
<uc6dnYYCztl1ypf-nZ2dnZfqlJzNnZ2d@giganews.com>
<i3tOK.1116035$X_i.273028@fx18.iad>
<EYKdnaeBBujH_5f-nZ2dnZfqlJ_NnZ2d@giganews.com>
<fBtOK.1187$SqO3.795@fx02.iad>
<Yb6dne3MJZKU9Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<o9uOK.1189$SqO3.1094@fx02.iad>
<F9adnUBBQ9_D7Jf-nZ2dnZfqlJzNnZ2d@giganews.com>
<zzuOK.876382$ntj.37244@fx15.iad>
<jvOdnaYqPfnBGpf-nZ2dnZfqlJzNnZ2d@giganews.com>
<tSvOK.125829$Ae2.104988@fx35.iad>
<qKKcnaG4BIBnEJf-nZ2dnZfqlJ_NnZ2d@giganews.com>
<IqwOK.172003$ze2.53966@fx36.iad>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <IqwOK.172003$ze2.53966@fx36.iad>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <CPOdnW8yhYxKBJf-nZ2dnZfqlJzNnZ2d@giganews.com>
Lines: 295
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-ox2Kd7EoZ4e8Z+CXp2KEybIl5zqZSJaNIhBU/S7eAAX5Taqmg52W+is0ZysvxaEmQ9hcmm8wgUmvQVd!2kqvjUSmnxrjc3UvZYoSCM6zg/YypdYNbgsu7QHu0BvOe6DfQRIqRfK7BJyuHJoPF4JIAjyYedk=
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
 by: olcott - Sat, 27 Aug 2022 22:25 UTC

On 8/27/2022 4:56 PM, Richard Damon wrote:
>
> On 8/27/22 5:34 PM, olcott wrote:
>> On 8/27/2022 4:18 PM, Richard Damon wrote:
>>> On 8/27/22 5:06 PM, olcott wrote:
>>>> On 8/27/2022 2:49 PM, Richard Damon wrote:
>>>>>
>>>>> On 8/27/22 3:32 PM, olcott wrote:
>>>>>> On 8/27/2022 2:21 PM, Richard Damon wrote:
>>>>>>> On 8/27/22 2:57 PM, olcott wrote:
>>>>>>>> On 8/27/2022 1:43 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 8/27/22 2:28 PM, olcott wrote:
>>>>>>>>>> On 8/27/2022 1:07 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 8/27/22 1:44 PM, olcott wrote:
>>>>>>>>>>>> On 8/27/2022 12:40 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 8/27/22 1:32 PM, olcott wrote:
>>>>>>>>>>>>>> On 8/27/2022 12:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 8/27/22 1:04 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>> On Sat, 27 Aug 2022 13:02:29 -0400
>>>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 8/27/22 12:55 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Cat got your tongue?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Or just caught wordless because you are seeing you have
>>>>>>>>>>>>>>>>> no answer?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> He is just replying to change the subject line to call
>>>>>>>>>>>>>>>> you a troll and
>>>>>>>>>>>>>>>> to say that I am clueless about software engineering.
>>>>>>>>>>>>>>>> He really is a
>>>>>>>>>>>>>>>> fucktard who has got nothing of value to contribute.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> True.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> He is just proving how stupid he is.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> He has sealed his eternal legacy at a Pathological Lying
>>>>>>>>>>>>>>> Idiot
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yep, he is just admitting that there is no truth in his
>>>>>>>>>>>>> statements he is admitting that he is wrong, but won't
>>>>>>>>>>>>> actually admit it.
>>>>>>>>>>>>>
>>>>>>>>>>>>> By ignoring the people pointing out errors, he shows that
>>>>>>>>>>>>> he is only interested in himself and not what is actually
>>>>>>>>>>>>> true.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I have pointed out all of the errors of all of your
>>>>>>>>>>>> rebuttals and instead of addressing these errors you change
>>>>>>>>>>>> the subject only to get back to make these same mistakes
>>>>>>>>>>>> again and again.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Really, point to an error I have made that you pointed out to
>>>>>>>>>>> any source other than "yourself" as grounds for me being wrong.
>>>>>>>>>>>
>>>>>>>>>>> I don't think you KNOW HOW to actually deal with a rebuttal.
>>>>>>>>>>>
>>>>>>>>>>> Note, I DON'T change the subject, I go to the core of what
>>>>>>>>>>> you are talking about, and you object to that as I don't let
>>>>>>>>>>> you build up a bed of half truths to try to make you ideas
>>>>>>>>>>> seem possibly plausable.
>>>>>>>>>>>
>>>>>>>>>>> Unless you ADMIT that you aren't talking about the Halting
>>>>>>>>>>> Theorm, all my comments are "On Topic" as I am just pointing
>>>>>>>>>>> out the basic definitions of the theory.
>>>>>>>>>>>
>>>>>>>>>>> YOU are the one that changes the subject.
>>>>>>>>>>>
>>>>>>>>>>> YOU FAIL.
>>>>>>>>>>
>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>> The correct and complete simulation of a machine description
>>>>>>>>>> always provides the actual behavior specified by this machine
>>>>>>>>>> description.
>>>>>>>>>
>>>>>>>>> Correct, and the machine description includes ALL the code
>>>>>>>>> executed by the program, including all subroutines/function it
>>>>>>>>> calls.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>> When-so-ever a simulating halt decider (SHD) correctly
>>>>>>>>>> performs a partial simulation of its input and the behavior of
>>>>>>>>>> this partial simulation correctly matches a correct
>>>>>>>>>> non-halting behavior pattern then the SHD halt decider can
>>>>>>>>>> correctly report non-halting.
>>>>>>>>>
>>>>>>>>> Yes, A CORRECT non-halting behavior pattern.
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>> A non-halting behavior pattern is correct when-so-ever
>>>>>>>>>> matching this behavior pattern proves that the simulated input
>>>>>>>>>> to the SHD would never stop running unless the SHD aborted its
>>>>>>>>>> simulation.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG, proving you are a LIAR, and and idiot.
>>>>>>>>>
>>>>>>>>> A non-halting behavior pattern is a pattern that means that a
>>>>>>>>> correct and complete simulation could never stop after seeing
>>>>>>>>> that pattern, in any machine.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No it doesn't mean anything like that.
>>>>>>>
>>>>>>> You have a reference for that, or are you going to just use
>>>>>>> incorrect logic to try to make your point.
>>>>>>>
>>>>>>>>
>>>>>>>> Example 01:
>>>>>>>> H0 correctly determines that Infinite_Loop() never halts
>>>>>>>>
>>>>>>>> void Infinite_Loop()
>>>>>>>> {
>>>>>>>>    HERE: goto HERE;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>> }
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00001102](01)  55         push ebp
>>>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>>>> [00001107](01)  5d         pop ebp
>>>>>>>> [00001108](01)  c3         ret
>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>
>>>>>>>> _main()
>>>>>>>> [00001192](01)  55         push ebp
>>>>>>>> [00001193](02)  8bec       mov ebp,esp
>>>>>>>> [00001195](05)  6802110000 push 00001102
>>>>>>>> [0000119a](05)  e8d3fbffff call 00000d72
>>>>>>>> [0000119f](03)  83c404     add esp,+04
>>>>>>>> [000011a2](01)  50         push eax
>>>>>>>> [000011a3](05)  68a3040000 push 000004a3
>>>>>>>> [000011a8](05)  e845f3ffff call 000004f2
>>>>>>>> [000011ad](03)  83c408     add esp,+08
>>>>>>>> [000011b0](02)  33c0       xor eax,eax
>>>>>>>> [000011b2](01)  5d         pop ebp
>>>>>>>> [000011b3](01)  c3         ret
>>>>>>>> Size in bytes:(0034) [000011b3]
>>>>>>>>
>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>   address   address   data      code       language
>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>> [00001192][00101ef8][00000000] 55         push ebp
>>>>>>>> [00001193][00101ef8][00000000] 8bec       mov ebp,esp
>>>>>>>> [00001195][00101ef4][00001102] 6802110000 push 00001102
>>>>>>>> [0000119a][00101ef0][0000119f] e8d3fbffff call 00000d72
>>>>>>>>
>>>>>>>> H0: Begin Simulation   Execution Trace Stored at:211fac
>>>>>>>> [00001102][00211f9c][00211fa0] 55         push ebp
>>>>>>>> [00001103][00211f9c][00211fa0] 8bec       mov ebp,esp
>>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>>> [00001105][00211f9c][00211fa0] ebfe       jmp 00001105
>>>>>>>> H0: Infinite Loop Detected Simulation Stopped
>>>>>>>>
>>>>>>>>   if (current->Simplified_Opcode == JMP)           // JMP
>>>>>>>>    if (current->Decode_Target <= current->Address) // upward
>>>>>>>>     if (traced->Address == current->Decode_Target) // to this
>>>>>>>> address
>>>>>>>>      if (Conditional_Branch_Count == 0)            // no escape
>>>>>>>>       return 1;
>>>>>>>>
>>>>>>>> [0000119f][00101ef8][00000000] 83c404     add esp,+04
>>>>>>>> [000011a2][00101ef4][00000000] 50         push eax
>>>>>>>> [000011a3][00101ef0][000004a3] 68a3040000 push 000004a3
>>>>>>>> [000011a8][00101ef0][000004a3] e845f3ffff call 000004f2
>>>>>>>> Input_Halts = 0
>>>>>>>> [000011ad][00101ef8][00000000] 83c408     add esp,+08
>>>>>>>> [000011b0][00101ef8][00000000] 33c0       xor eax,eax
>>>>>>>> [000011b2][00101efc][00100000] 5d         pop ebp
>>>>>>>> [000011b3][00101f00][00000004] c3         ret
>>>>>>>> Number of Instructions Executed(554) == 8 Pages
>>>>>>>>
>>>>>>>>> Halting is a property of the MACHINE, that is the MACHINE the
>>>>>>>>> input specified.
>>>>>>>>
>>>>>>>> If halt deciders examined machines you would be correct.
>>>>>>>> Halt deciders never examine machines.
>>>>>>>> Halt deciders always examine finite string machine descriptions.
>>>>>>>
>>>>>>> Isn't the finite string the machine code?
>>>>>>>
>>>>>>> I thought you defined your "finite string" to BE the machine code
>>>>>>> for your machine.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> Because a simulating halt decider is a pure simulator that has
>>>>>>>> extra features added to it a simulating halt decider that never
>>>>>>>> aborts its simulation is simply a pure simulator thus
>>>>>>>
>>>>>>> So does your H abort its simulation or not.
>>>>>>>
>>>>>>> If it doesn't, then YES, it does a pure simulation and thus
>>>>>>> doesn't stop until the input reaches a final state, and thus
>>>>>>> never answers for a non-halting input, or
>>>>>>>
>>>>>>> if it DOES, then it can't be the source of what a pure simulator
>>>>>>> does, since it isn't one.
>>>>>>>
>>>>>>> Pleae show me a program that does BOTH be a pure simulator that
>>>>>>> simulates the non-halting input until it (never) reaches the
>>>>>>> final state, and also aborts its simulation to return the
>>>>>>> non-halting answer, at the same time.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> A non-halting behavior pattern is correct when-so-ever matching
>>>>>>>> this
>>>>>>>> behavior pattern proves that the simulated input to the SHD would
>>>>>>>> never stop running unless the SHD aborted its simulation.
>>>>>>>>
>>>>>>>
>>>>>>> Nope. Proven wrong and illogical. You can't ask about behavior of
>>>>>>> a program (the SHD) that isn't part of the system. The
>>>>>>> "non-aborting" SHD is NOT the SHD, so you condition just doesn't
>>>>>>> occur.
>>>>>>
>>>>>> A simulating halt decider
>>>>>> CORRECTLY PREDICTS WHAT THE BEHAVIOR OF ITS INPUT WOULD BE IF IT
>>>>>> NEVER ABORTED THE SIMULATION OF THIS INPUT
>>>>>>
>>>>>
>>>>> Then it isn't a Halt Decider. PERIOD.
>>>>>
>>>>> A REAL Halt Decider decides on the behavior of the machine
>>>>> represented by its input, not the behavior of itself.
>>>> *Ah so that was my best wording*
>>>>
>>>> (a) Every decider must compute the mapping from its input finite
>>>> string based on a semantic or syntactic property of this finite string.
>>>
>>> Right, and the propert of this finite string is the behavior of UTM(P,d)
>>>
>>
>> No not at all. The decider could be determining whether or not an
>> input string contains: "A".
>
>
> That would be deciding on a syntactic property.
>
> A semantic property is something like Halting of UTM(P,d).
>
> Maybe you don't understand what you can ask a decider.
>>
>>>>
>>>> (b) A halt decider must compute the mapping from its input finite
>>>> string to an accept or reject state based on the actual behavior of
>>>> its actual input.
>>>
>>> Right, and that is whether UTM(P,d) Halts or not.
>>
>> When H correctly predicts that its input would never stop running
>> unless it aborts its simulation of this input it is correctly
>> predicting whether or not the pure (AKA UTM) simulation of its input
>> would stop running because H is a pure (AKA UTM) simulator when it
>> does not abort its simulation.
>
> Nope, Px(Px) is the simple counter example.


Click here to read the complete article

devel / comp.theory / Re: Olcott [ Ben contradicts himself ]

Pages:123456789101112
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor