Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

Life is difficult because it is non-linear.

tech / sci.math / Re: Experts would agree that my reviewers are incorrect [ brain-dead morons ]

Re: Experts would agree that my reviewers are incorrect [ brain-dead morons ]

<h5qdnRcIzongGhP_nZ2dnUU7_81g4p2d@giganews.com>

  copy mid

https://www.novabbs.com/tech/article-flat.php?id=101045&group=sci.math#101045

  copy link   Newsgroups: comp.theory comp.ai.philosophy sci.logic sci.math
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!buffer2.nntp.dca1.giganews.com!news.giganews.com.POSTED!not-for-mail
NNTP-Posting-Date: Wed, 25 May 2022 14:46:05 -0500
Date: Wed, 25 May 2022 14:46:04 -0500
MIME-Version: 1.0
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.9.1
Subject: Re: Experts would agree that my reviewers are incorrect [ brain-dead
morons ]
Content-Language: en-US
Newsgroups: comp.theory,comp.ai.philosophy,sci.logic,sci.math
References: <ZsGdnbObotHZcxH_nZ2dnUU7_8zNnZ2d@giganews.com>
<t6k4k0$5hj$1@dont-email.me>
<b855ef33-09c6-40e8-bf7a-349e8f2136can@googlegroups.com>
<woGdnUC1S4MZBBD_nZ2dnUU7_8zNnZ2d@giganews.com>
<0UgjK.27591$3Gzd.26207@fx96.iad>
<L7WdnWGMIJ8iBhD_nZ2dnUU7_8zNnZ2d@giganews.com>
<30ojK.56334$5fVf.47342@fx09.iad>
<FdednYTsy5AfpBP_nZ2dnUU7_83NnZ2d@giganews.com>
<003a2286-b576-4bee-bf8a-0a4f52b86fe6n@googlegroups.com>
<ZrKdnYIoec5boBP_nZ2dnUU7_8xh4p2d@giganews.com>
<6d38eab9-5a39-480d-8515-b7832d449139n@googlegroups.com>
<icCdnTNMG7za3hP_nZ2dnUU7_8zNnZ2d@giganews.com>
<286a794f-221d-4e98-beb2-5089afb10a47n@googlegroups.com>
<mYCdndreScbv7hP_nZ2dnUU7_8xh4p2d@giganews.com>
<6a2481ce-a21b-4add-9b9e-4cac50f7f9e6n@googlegroups.com>
<rc-dneaYc_Um6xP_nZ2dnUU7_81g4p2d@giganews.com>
<bd4b5d20-ce07-4100-83d5-ade85c2fb246n@googlegroups.com>
<rc-dneCYc_U16hP_nZ2dnUU7_81g4p2d@giganews.com>
<04729357-aa79-408c-b993-82855e2579cdn@googlegroups.com>
<h5qdnRQIzomIGhP_nZ2dnUU7_83NnZ2d@giganews.com>
From: NoO...@NoWhere.com (olcott)
In-Reply-To: <h5qdnRQIzomIGhP_nZ2dnUU7_83NnZ2d@giganews.com>
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Message-ID: <h5qdnRcIzongGhP_nZ2dnUU7_81g4p2d@giganews.com>
Lines: 355
X-Usenet-Provider: http://www.giganews.com
X-Trace: sv3-XTOkTCvWycq5NCBn1vXNx+nCglOEvR97cdNvriZgj+LU5nBHBzOWTklDyKf/G2HYGPyjmRU8wmlBUYq!4nlBtGc2omr2iXAFOQPmOfbnfKW5jkX6tpC6hbczyQ5F3whS82EahabQ8N/cRjMUck22G+hR1zA=
X-Complaints-To: abuse@giganews.com
X-DMCA-Notifications: http://www.giganews.com/info/dmca.html
X-Abuse-and-DMCA-Info: Please be sure to forward a copy of ALL headers
X-Abuse-and-DMCA-Info: Otherwise we will be unable to process your complaint properly
X-Postfilter: 1.3.40
X-Original-Bytes: 19526
 by: olcott - Wed, 25 May 2022 19:46 UTC

On 5/25/2022 2:44 PM, olcott wrote:
> On 5/25/2022 1:42 PM, Dennis Bush wrote:
>> On Wednesday, May 25, 2022 at 2:38:40 PM UTC-4, olcott wrote:
>>> On 5/25/2022 1:36 PM, Dennis Bush wrote:
>>>> On Wednesday, May 25, 2022 at 2:34:42 PM UTC-4, olcott wrote:
>>>>> On 5/25/2022 1:28 PM, Dennis Bush wrote:
>>>>>> On Wednesday, May 25, 2022 at 2:20:41 PM UTC-4, olcott wrote:
>>>>>>> On 5/25/2022 10:01 AM, Dennis Bush wrote:
>>>>>>>> On Wednesday, May 25, 2022 at 10:55:11 AM UTC-4, olcott wrote:
>>>>>>>>> On 5/25/2022 9:35 AM, Dennis Bush wrote:
>>>>>>>>>> On Wednesday, May 25, 2022 at 10:31:41 AM UTC-4, olcott wrote:
>>>>>>>>>>> On 5/25/2022 9:20 AM, Dennis Bush wrote:
>>>>>>>>>>>> On Wednesday, May 25, 2022 at 10:13:30 AM UTC-4, olcott wrote:
>>>>>>>>>>>>> On 5/25/2022 6:01 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 5/24/22 11:00 PM, olcott wrote:
>>>>>>>>>>>>>>> On 5/24/2022 9:54 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 5/24/22 10:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 5/24/2022 9:39 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 10:34:43 PM UTC-4, olcott
>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>> On 5/24/2022 9:30 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 10:28:14 PM UTC-4,
>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 9:20 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 10:16:10 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 9:08 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 10:03:59 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 8:56 PM, Dennis Bush wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, May 24, 2022 at 9:33:19 PM UTC-4,
>>>>>>>>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 8:12 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/22 5:34 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 4:27 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tue, 24 May 2022 16:12:13 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 5/24/2022 3:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tue, 24 May 2022 09:40:02 -0500
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> olcott <No...@NoWhere.com> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> All of the recent discussions are simply
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disagreement with an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easily verifiable fact. Any smart
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> software engineer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> sufficient technical background can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> easily confirm
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(P,P)==0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is correct:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Where H is a C function that correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input pair of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> finite strings of the x86 machine code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of function P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and criterion
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for returning 0 is that the simulated P
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reach its "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The only reason P "never" reaches its "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction is because
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have introduced an infinite
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> recursion that does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not exist in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the proofs you are trying to refute,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> i.e. your H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> erroneous.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For the time being I am only referring to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when the C
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> function named H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether ore not its correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the machine
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> language of P would ever reach the "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P in 0 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinity number of steps of correct x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You can't have it both ways: either H is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> supposed to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a decider or it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't; if it is a decider then it fails at
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have introduced
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an infinite recursion; if it isn't a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider and is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> merely a tool for
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> refuting the proofs then it fails at that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> too as the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proofs you are
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> trying to refute do not contain an
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinite recursion.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have to actually stick with the words
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that I
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually said as the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> basis of any rebuttal.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct x86
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) would never reach the "ret"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P in 0 to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> infinity steps of the correct x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P by H.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you have posted a trace which shows
>>>>>>>>>>>>>>>>>>>>>>>>>>>> this happening,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you know this
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is a lie.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, H can't simulate to there, but a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> CORRECT simulator can.
>>>>>>>>>>>>>>>>>>>>>>>>>>> H makes no mistakes in its simulation. Every
>>>>>>>>>>>>>>>>>>>>>>>>>>> instruction
>>>>>>>>>>>>>>>>>>>>>>>>>>> that H
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulates is exactly what the x86 source-code
>>>>>>>>>>>>>>>>>>>>>>>>>>> for P
>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ha3(N,5) makes no mistakes in its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>> Every
>>>>>>>>>>>>>>>>>>>>>>>>>> instruction that Ha3 simulates is exactly what
>>>>>>>>>>>>>>>>>>>>>>>>>> the x86
>>>>>>>>>>>>>>>>>>>>>>>>>> source code for N specifies. Therefore,
>>>>>>>>>>>>>>>>>>>>>>>>>> according to you,
>>>>>>>>>>>>>>>>>>>>>>>>>> Ha3(N,5)==0 is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Oh, you disagree? Then the fact that Ha makes
>>>>>>>>>>>>>>>>>>>>>>>>>> no mistakes
>>>>>>>>>>>>>>>>>>>>>>>>>> in its simulation doesn't mean that it's correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The only possible way for a simulator to
>>>>>>>>>>>>>>>>>>>>>>>>>>> actually be
>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect is that
>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation diverges from what the x86
>>>>>>>>>>>>>>>>>>>>>>>>>>> source-code of P
>>>>>>>>>>>>>>>>>>>>>>>>>>> specifies.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Or it aborts a halting computation,
>>>>>>>>>>>>>>>>>>>>>>>>>> incorrectly thinking
>>>>>>>>>>>>>>>>>>>>>>>>>> that it is a non-halting computation. Which is
>>>>>>>>>>>>>>>>>>>>>>>>>> exactly what
>>>>>>>>>>>>>>>>>>>>>>>>>> happens with Ha(Pa,Pa).
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That Simulate(P,P) does not have the same
>>>>>>>>>>>>>>>>>>>>>>>>>>> halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>> as the
>>>>>>>>>>>>>>>>>>>>>>>>>>> correct simulation of the input to H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>> does not mean
>>>>>>>>>>>>>>>>>>>>>>>>>>> that either one
>>>>>>>>>>>>>>>>>>>>>>>>>>> of them is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa), by the definition of the halting
>>>>>>>>>>>>>>>>>>>>>>>>>> problem, does
>>>>>>>>>>>>>>>>>>>>>>>>>> not perform a correct simulation of its input.
>>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that the correct
>>>>>>>>>>>>>>>>>>>>>>>>> x86 emulation
>>>>>>>>>>>>>>>>>>>>>>>>> of the
>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) would never reach the "ret"
>>>>>>>>>>>>>>>>>>>>>>>>> instruction of P
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> It is an easily verified fact that Ha(Pa,Pa)==0
>>>>>>>>>>>>>>>>>>>>>>>> is not
>>>>>>>>>>>>>>>>>>>>>>>> correct because it aborts too soon as
>>>>>>>>>>>>>>>>>>>>>>>> demonstrated by
>>>>>>>>>>>>>>>>>>>>>>>> Hb(Pa,Pa)==1
>>>>>>>>>>>>>>>>>>>>>>> By this same despicable liar reasoning we can
>>>>>>>>>>>>>>>>>>>>>>> know that Fluffy
>>>>>>>>>>>>>>>>>>>>>>> is not
>>>>>>>>>>>>>>>>>>>>>>> a white cat entirely on the basis that Rover is a
>>>>>>>>>>>>>>>>>>>>>>> black dog.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> It is the actual behavior that the x86
>>>>>>>>>>>>>>>>>>>>>>> source-code of P
>>>>>>>>>>>>>>>>>>>>>>> specifies to
>>>>>>>>>>>>>>>>>>>>>>> H(P,P) and H1(P,P)
>>>>>>>>>>>>>>>>>>>>>>> that determines whether or not its simulation by H
>>>>>>>>>>>>>>>>>>>>>>> and H1 is correct.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Then by this same logic you agree that
>>>>>>>>>>>>>>>>>>>>> You continue to be a liar.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So no rebuttal, which means you're unable to. Which
>>>>>>>>>>>>>>>>>>>> means you
>>>>>>>>>>>>>>>>>>>> admit I'm right.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So what are you going to do with yourself now that
>>>>>>>>>>>>>>>>>>>> you're no
>>>>>>>>>>>>>>>>>>>> longer working on the halting problem?
>>>>>>>>>>>>>>>>>>> Escalate the review to a higher caliber reviewer.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Now that I have all of the objections boiled down to
>>>>>>>>>>>>>>>>>>> simply
>>>>>>>>>>>>>>>>>>> disagreeing
>>>>>>>>>>>>>>>>>>> with two verifiable facts higher caliber reviewers
>>>>>>>>>>>>>>>>>>> should confirm
>>>>>>>>>>>>>>>>>>> that I
>>>>>>>>>>>>>>>>>>> am correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The verifiable fact that everyone (except you) can see
>>>>>>>>>>>>>>>>>> is that
>>>>>>>>>>>>>>>>>> Hb(Pa,Pa)==1 proves that Ha(Pa,Pa)==0 is wrong,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Shows that they are not basing their decision on the
>>>>>>>>>>>>>>>>> execution trace
>>>>>>>>>>>>>>>>> that is actually specified by the x86 source-code of P.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> There is no Ha(Pa,Pa) or Hb(Pa,Pa) these are actually
>>>>>>>>>>>>>>>>> named H(P,P)
>>>>>>>>>>>>>>>>> and H1(P,P). You can't even manage to tell the truth
>>>>>>>>>>>>>>>>> about the names
>>>>>>>>>>>>>>>>> of functions.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The names really make that much difference?
>>>>>>>>>>>>>>> H(P,P) and H1(P,P) are fully operational C functions that
>>>>>>>>>>>>>>> can be
>>>>>>>>>>>>>>> executed showing every detail of their correct simulation
>>>>>>>>>>>>>>> of their
>>>>>>>>>>>>>>> inputs.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Ha(Pa,Pa) and Hb(Pa,Pa) are vague ideas that cannot
>>>>>>>>>>>>>>> possibly be pinned
>>>>>>>>>>>>>>> down to specifics. The only place that Dennis can hide
>>>>>>>>>>>>>>> his deception
>>>>>>>>>>>>>>> is in deliberate vagnueness.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, you don't understand what peeople are saying. For you
>>>>>>>>>>>>>> it is just
>>>>>>>>>>>>>> that you are right and others are wrong.
>>>>>>>>>>>>> Ha(Pa,Pa) is fully operational code named H(P,P)
>>>>>>>>>>>>> Hb(Pa,Pa) is fully operational code named H1(P,P)
>>>>>>>>>>>>>
>>>>>>>>>>>>> I can prove that the actual behavior of the correct x86
>>>>>>>>>>>>> emulation of
>>>>>>>>>>>>> actual input to H(P,P) never reaches its "ret" instruction
>>>>>>>>>>>>> with a full
>>>>>>>>>>>>> execution trace of P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I can prove that the actual behavior of the correct x86
>>>>>>>>>>>>> emulation of
>>>>>>>>>>>>> actual input to H1(P,P) reaches its "ret" instruction with
>>>>>>>>>>>>> a full
>>>>>>>>>>>>> execution trace of P.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I can prove that both of these execution traces are correct
>>>>>>>>>>>>> on the basis
>>>>>>>>>>>>> of the behavior that is specified by the x86 source-code
>>>>>>>>>>>>> for P.
>>>>>>>>>>>>
>>>>>>>>>>>> Now create Ha3, Ha7 and N, and produce traces of Ha3(N,5)
>>>>>>>>>>>> and Ha7(N,5) and tell us what you see.
>>>>>>>>>>>>
>>>>>>>>>>> If H(P,P) is proven to be correct then there is no need to
>>>>>>>>>>> look at
>>>>>>>>>>> anything else. I am not writing a paper about every program
>>>>>>>>>>> that can
>>>>>>>>>>> possibly ever be written. I am wring a paper about H(P,P). Once
>>>>>>>>>>> H(P,P)==0 is proven to be correct then all of the HP proof
>>>>>>>>>>> are refuted.
>>>>>>>>>>
>>>>>>>>>> If your proof of H(P,P)==0 being correct also concludes that
>>>>>>>>>> Ha3(N,5)==0 is correct, then you have an invalid proof as it
>>>>>>>>>> creates nonsense results.
>>>>>>>>> _P()
>>>>>>>>> [00001352](01) 55 push ebp
>>>>>>>>> [00001353](02) 8bec mov ebp,esp
>>>>>>>>> [00001355](03) 8b4508 mov eax,[ebp+08]
>>>>>>>>> [00001358](01) 50 push eax // push P
>>>>>>>>> [00001359](03) 8b4d08 mov ecx,[ebp+08]
>>>>>>>>> [0000135c](01) 51 push ecx // push P
>>>>>>>>> [0000135d](05) e840feffff call 000011a2 // call H
>>>>>>>>> [00001362](03) 83c408 add esp,+08
>>>>>>>>> [00001365](02) 85c0 test eax,eax
>>>>>>>>> [00001367](02) 7402 jz 0000136b
>>>>>>>>> [00001369](02) ebfe jmp 00001369
>>>>>>>>> [0000136b](01) 5d pop ebp
>>>>>>>>> [0000136c](01) c3 ret
>>>>>>>>> Size in bytes:(0027) [0000136c]
>>>>>>>>> It is an easily verified fact that the correct x86 emulation of
>>>>>>>>> the
>>>>>>>>> input to H(P,P) would never reach the "ret" instruction of P in
>>>>>>>>> 0 to
>>>>>>>>> infinity steps of the correct x86 emulation of P by H.
>>>>>>>>
>>>>>>>> It is an easily verified fact that the correct x86 emulation of
>>>>>>>> the input to Ha3(N,5) would never reach the "ret" instruction of
>>>>>>>> N in 0 to infinity steps of the correct x86 emulation of N by Ha3.
>>>>>>>>
>>>>>>> God damned liars always change the subject when they know that
>>>>>>> that have
>>>>>>> been correctly refuted.
>>>>>>
>>>>>> Wrong on both counts.
>>>>> Liar
>>>>
>>>> Then why am I wrong?
>>> It seems to me that you are wrong because you are hard-wired to be a
>>> liar.
>>
>> No explanation.  That you means you admit that I'm right that
>> Ha(Pa,Pa)==0 (which you refer to as H(P,P)==0) is wrong and that your
>> last 18 years of work have been for naught.
>
> _P()
> [00001352](01)  55              push ebp
> [00001353](02)  8bec            mov ebp,esp
> [00001355](03)  8b4508          mov eax,[ebp+08]
> [00001358](01)  50              push eax      // push P
> [00001359](03)  8b4d08          mov ecx,[ebp+08]
> [0000135c](01)  51              push ecx      // push P
> [0000135d](05)  e840feffff      call 000011a2 // call H
> [00001362](03)  83c408          add esp,+08
> [00001365](02)  85c0            test eax,eax
> [00001367](02)  7402            jz 0000136b
> [00001369](02)  ebfe            jmp 00001369
> [0000136b](01)  5d              pop ebp
> [0000136c](01)  c3              ret
> Size in bytes:(0027) [0000136c]
>
> Any brain-dead moron knows that a correct x86 emulation of the input to
> H(P,P) would result in the first seven instructions of P being emulated.
>
> The same extremely stupid person would also know that when P calls
> H(P,P) that the same first seven instructions of P would be emulated again.
>

It might take an actual moron (that is not brain dead) to be able to see
that the correctly emulated input to H(P,P) would never reach its “ret”
instruction.

--
Copyright 2022 Pete Olcott

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

SubjectRepliesAuthor
o Re: Experts would agree that my reviewers are incorrect

By: Mr Flibble on Tue, 24 May 2022

67Mr Flibble
server_pubkey.txt

rocksolid light 0.9.81
clearnet tor