On Wednesday, May 25, 2022 at 11:17:28 PM UTC-4, olcott wrote:
> On 5/25/2022 10:09 PM, Richard Damon wrote:
> > On 5/25/22 10:53 PM, olcott wrote:
> >> On 5/25/2022 9:39 PM, Richard Damon wrote:
> >>>
> >>> On 5/25/22 10:07 PM, olcott wrote:
> >>>> On 5/25/2022 8:35 PM, Richard Damon wrote:
> >>>>> On 5/25/22 9:26 PM, olcott wrote:
> >>>>>> On 5/25/2022 8:08 PM, Dennis Bush wrote:
> >>>>>>> On Wednesday, May 25, 2022 at 9:03:51 PM UTC-4, olcott wrote:
> >>>>>>>> On 5/25/2022 7:42 PM, Dennis Bush wrote:
> >>>>>>>>> On Wednesday, May 25, 2022 at 8:33:34 PM UTC-4, olcott wrote:
> >>>>>>>>>> On 5/25/2022 7:25 PM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, May 25, 2022 at 5:52:58 PM UTC-4, olcott wrote:
> >>>>>>>>>>>> On 5/25/2022 4:37 PM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Wednesday, May 25, 2022 at 5:14:49 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>> On 5/25/2022 3:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Wednesday, May 25, 2022 at 4:41:13 PM UTC-4, olcott
> >>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>> On 5/25/2022 3:31 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Wednesday, May 25, 2022 at 4:23:33 PM UTC-4, olcott
> >>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>> On 5/25/2022 2:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Wednesday, May 25, 2022 at 3:44:29 PM UTC-4,
> >>>>>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> They would also know that a correct simulation would
> >>>>>>>>>>>>>>>>>>> see the Ha that Pa called will abort *its* simulation
> >>>>>>>>>>>>>>>>>>> of Pa and returns 0, causing the original simulated
> >>>>>>>>>>>>>>>>>>> Pa to reach its "ret" instruction and halt. Which
> >>>>>>>>>>>>>>>>>>> proves that Ha(Pa,Pa)==0 is the wrong answer.
> >>>>>>>>>>>>>>>>>> So when H(P,P) called from main() returns it returns
> >>>>>>>>>>>>>>>>>> to P.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, a CORRECT simulation, i.e. one done by UTM(Pa,Pa)
> >>>>>>>>>>>>>>>>> or H1(Pa,Pa), sees that the copy of Ha inside of Pa
> >>>>>>>>>>>>>>>>> will as per its fixed algorithm abort and return 0,
> >>>>>>>>>>>>>>>>> causing the simulated Pa to reach its "ret" instruction
> >>>>>>>>>>>>>>>>> and reach a final state.
> >>>>>>>>>>>>>>>> So your proof that Rover is not a black dog keeps coming
> >>>>>>>>>>>>>>>> back to the
> >>>>>>>>>>>>>>>> fact that Fluffy is a white cat therefore Rover cannot
> >>>>>>>>>>>>>>>> be a black dog.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Irrelevant babbling
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> The actual execution trace P that the x86 machine
> >>>>>>>>>>>>>>>> language of P for
> >>>>>>>>>>>>>>>> H(P,P) never reaches its "ret" instruction and
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Because Ha(Pa,Pa) aborts its simulation too soon.
> >>>>>>>>>>>>>> How many instances of recursive emulation would be enough?
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> In the case of Pa, one more than Ha does.
> >>>>>>>>>>>> In other words for any integer N if Ha waits N recursive
> >>>>>>>>>>>> emulations
> >>>>>>>>>>>> before it aborts its emulation this was one less than it
> >>>>>>>>>>>> needed to wait
> >>>>>>>>>>>> for every integer N.
> >>>>>>>>>>>
> >>>>>>>>>>> No, for the fixed number of emulations n that the fixed
> >>>>>>>>>>> algorithm Ha performs, it is unable to see Pa(Pa) reach a
> >>>>>>>>>>> final state.
> >>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>> [000012c2](01) 55 push ebp
> >>>>>>>>>> [000012c3](02) 8bec mov ebp,esp
> >>>>>>>>>> [000012c5](02) ebfe jmp 000012c5
> >>>>>>>>>> [000012c7](01) 5d pop ebp
> >>>>>>>>>> [000012c8](01) c3 ret
> >>>>>>>>>> Size in bytes:(0007) [000012c8]
> >>>>>>>>>>
> >>>>>>>>>> Yes and the same goes for the above.
> >>>>>>>>>> According to your reasoning infinite loops, infinite recursion
> >>>>>>>>>> and
> >>>>>>>>>> infinitely nested simulation all halt after a finite number of
> >>>>>>>>>> instructions.
> >>>>>>>>>
> >>>>>>>>> That is not remotely what I said.
> >>>>>>>>>
> >>>>>>>>> What I said is that the fixed algorithm of Ha is unable to
> >>>>>>>>> simulate Pa(Pa) to a final state. It *mistakenly* thinks there
> >>>>>>>>> is infinitely nested simulation, but there is not since Pa(Pa)
> >>>>>>>>> halts.
> >>>>>>>> The execution trace of some of the steps of the simulated input
> >>>>>>>> conclusively proves that it never reaches its "ret" instruction
> >>>>>>>
> >>>>>>> What it shows is that Ha is unable to simulate Pa(Pa) to a final
> >>>>>>> state. But H1 *can* simulate it to a final state, so Ha is wrong.
> >>>>>>>
> >>>>>>>> in the
> >>>>>>>> same way that the execution trace of some of the steps of
> >>>>>>>> _Infinite_Loop() conclusively proves that it never reaches its
> >>>>>>>> "ret"
> >>>>>>>
> >>>>>>> The difference is that UTM(Infinite_Loop,"") does not halt, while
> >>>>>>> UTM(Pa,Pa) does. In other words, Ha *mistakenly* thinks there
> >>>>>>> is infinitely nested simulation, but there is not since Pa(Pa)
> >>>>>>> halts.
> >>>>>>
> >>>>>> H correctly determines in a finite number of steps that its
> >>>>>> simulated input would never reach its "ret" instruction in an
> >>>>>> infinite number of steps of correct simulation.
> >>>>>
> >>>>> Can't since H1 proves that the correct simulation of THAT input
> >>>>> does reach the ret instruction in a finite number of steps.
> >>>>>
> >>>> It is the behavior that the x86 machine code specifies to its x86
> >>>> emulator that is the ultimate measure of the correctness of the
> >>>> simulation.
> >>>>
> >>>> You and Dennis seem to think that you can disagree with the x86
> >>>> language because the execution trace that its specifies does not
> >>>> agree with you intuition.
> >>>>
> >>>> This is the exact same kind of thing as disagreeing with arithmetic.
> >>>>
> >>>
> >>> You still don't get it do you. its not to "Its" simulator, but to ANY
> >>> simulator, as ALL x86 simulators, if they are correct, will get the
> >>> same simulation of identical code.
> >>>
> >>
> >> Yet when we actually simulate them on an actual x86 emulator we find
> >> that their verifiably correct simulation by H(P,P) and H1(P,P) does
> >> indeed specify different halting behavior.
> >>
> >> We can't say that the simulation is wrong because the simulation does
> >> behave exactly as the x86 source-code of P specifies.
> >>
> >>
> >
> > As I have said, that PROVES that your H is not a computation, and thus
> > can't be a Halt Decider.
> >
> > Two simulation of the same code of a computation must generate the same
> > results.
> This is merely a false assumption that is directly contradicted by the
> verified facts.

No, it is *stipulated* that they must be the same. So if they differ, one is necessarily incorrect. They don't specify different computations just because you want them to.