On Wed, 17 Aug 2022 13:42:36 -0500
olcott <NoOne@NoWhere.com> wrote:

> On 8/17/2022 1:35 PM, Mr Flibble wrote:
> > On Wed, 17 Aug 2022 13:29:36 -0500
> > olcott <NoOne@NoWhere.com> wrote:
> >
> >> On 8/17/2022 1:21 PM, Mr Flibble wrote:
> >>> On Wed, 17 Aug 2022 13:13:32 -0500
> >>> olcott <NoOne@NoWhere.com> wrote:
> >>>
> >>>> On 8/17/2022 1:09 PM, Mr Flibble wrote:
> >>>>> On Wed, 17 Aug 2022 13:05:33 -0500
> >>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>
> >>>>>> On 8/17/2022 12:53 PM, Mr Flibble wrote:
> >>>>>>> On Wed, 17 Aug 2022 12:44:17 -0500
> >>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>
> >>>>>>>> On 8/17/2022 12:35 PM, Mr Flibble wrote:
> >>>>>>>>> On Wed, 17 Aug 2022 12:30:38 -0500
> >>>>>>>>> olcott <NoOne@NoWhere.com> wrote:
> >>>>>>>>>
> >>>>>>>>>> On 8/17/2022 11:57 AM, Dennis Bush wrote:
> >>>>>>>>>>> On Wednesday, August 17, 2022 at 12:55:38 PM UTC-4, olcott
> >>>>>>>>>>> wrote:
> >>>>>>>>>>>> On 8/17/2022 11:25 AM, Dennis Bush wrote:
> >>>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:19:51 PM UTC-4,
> >>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>> On 8/17/2022 11:06 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 11:55:36 AM UTC-4,
> >>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>> On 8/17/2022 10:35 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 11:24:34 AM UTC-4,
> >>>>>>>>>>>>>>>>> olcott wrote:
> >>>>>>>>>>>>>>>>>> On 8/17/2022 9:51 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 10:23:17 AM
> >>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 8/17/2022 6:40 AM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>> On Wednesday, August 17, 2022 at 12:28:52 AM
> >>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 11:02 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:57:51 PM
> >>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 10:53 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:39:32 PM
> >>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 10:23 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 11:18:46 PM
> >>>>>>>>>>>>>>>>>>>>>>>>>>> UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:52 PM, Dennis Bush wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at 10:47:57
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:34 PM, Dennis Bush
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, August 16, 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 10:12:55 PM UTC-4, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:55 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 9:20 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 8:10 PM, Richard Damon
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/22 10:27 AM, olcott
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 8/16/2022 9:07 AM, Skep Dick
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On Tuesday, 16 August 2022 at
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 15:55:30 UTC+2, olcott wrote:
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of the input to
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) by H WOULD never stop
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Sounds like you are stuck in a
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> loop.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Maybe your Decider/Maker should
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> terminate you.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I have been trying to get an
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> honest person to acknowledge the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct software engineering of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> my system so that we can move on
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to the next point for a year
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> now. (bot many honest people
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> here, mostly trolls).
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The problem is that what you say
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ISN'T CORRECT software
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You use the wrong definition of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> things and incorrect assumptions
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> about thing, so it just isn't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> true.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) does correctly predict
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that its correct and complete x86
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of its input would
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stop running, thus does
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly reject this input as
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. And in fact, you even
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> acknoldge it doesn't but just
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> don't see it.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are saying that the correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation by
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) of its input WOULD STOP
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> RUNNING?
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, I am saying that you H doesn't
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do a correct and complete emulation
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its input, and thus to say it
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> did is just a LIE.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I said that H correctly predicts what
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the behavior of its correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete x86 emulation of H(P,P)
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would be
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The fixed source code of H (and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> everything it calls) that aborts is
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha. Ha *always* aborts Pa, so "the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correct and complete simulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa)" does not exist, just like
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the shoes that Napoleon wore on Mars
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> do not exist.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are another brain dead moron the
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> believes it is utterly impossible for H
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to correctly predict that its correct
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> and complete x86 emulation of its
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input would never stop running unless
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H actually performed a correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> complete emulation of its input.
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> The correct and complete emulation of
> >>>>>>>>>>>>>>>>>>>>>>>>>>>>> Ha(Pa,Pa) doesn't exist,
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> Neither does the correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>>>> emulation of Infinite_Loop()
> >>>>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Yes it does. If you simulate
> >>>>>>>>>>>>>>>>>>>>>>>>>>> Infinite_Loop(), it won't halt. But if you
> >>>>>>>>>>>>>>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and
> >>>>>>>>>>>>>>>>>>>>>>>>>>> complete simulation because it aborts.
> >>>>>>>>>>>>>>>>>>>>>>>>>> When you run H0((u32)Infinite_Loop)
> >>>>>>>>>>>>>>>>>>>>>>>>>> "it won't do a correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>>>> simulation because it aborts" How long are
> >>>>>>>>>>>>>>>>>>>>>>>>>> you going to keep the head game up?
> >>>>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>>>> That you don't understand what I'm saying
> >>>>>>>>>>>>>>>>>>>>>>>>> doesn't make it a head game.
> >>>>>>>>>>>>>>>>>>>>>>>> You reject Ha(Pa,Pa) on this basis
> >>>>>>>>>>>>>>>>>>>>>>>> run Ha(Pa,Pa), it won't do a correct and
> >>>>>>>>>>>>>>>>>>>>>>>> complete simulation because it aborts.
> >>>>>>>>>>>>>>>>>>>>>>>> Yet accept P0(Infinite_Loop), on the same
> >>>>>>>>>>>>>>>>>>>>>>>> basis it won't do a correct and complete
> >>>>>>>>>>>>>>>>>>>>>>>> simulation because it aborts. ∴ You are
> >>>>>>>>>>>>>>>>>>>>>>>> playing head games.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> What does P0 do? Does it abort? If so, then
> >>>>>>>>>>>>>>>>>>>>>>> yes P0(Infinite_Loop) doesn't do a correct and
> >>>>>>>>>>>>>>>>>>>>>>> complete simulation because it aborts, so it's
> >>>>>>>>>>>>>>>>>>>>>>> invalid to predict what the correct and
> >>>>>>>>>>>>>>>>>>>>>>> complete simulation of P0(Infinite_Loop)
> >>>>>>>>>>>>>>>>>>>>>>> would do.
> >>>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>>> On the other hand, UTM(Infinite_Loop) does do
> >>>>>>>>>>>>>>>>>>>>>>> a correct and complete simulation, so it *is*
> >>>>>>>>>>>>>>>>>>>>>>> valid to predict what it will do.
> >>>>>>>>>>>>>>>>>>>>>> In other words you are not bright enough to see
> >>>>>>>>>>>>>>>>>>>>>> that it is very easy for H0 to recognize an
> >>>>>>>>>>>>>>>>>>>>>> infinite loop would never halt in a finite
> >>>>>>>>>>>>>>>>>>>>>> number of steps of simulation?
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I'm saying that H0 can see that the correct and
> >>>>>>>>>>>>>>>>>>>>> complete simulation performed by
> >>>>>>>>>>>>>>>>>>>>> UTM(Infinite_Loop) does not halt. It does not
> >>>>>>>>>>>>>>>>>>>>> and cannot see that the correct and complete
> >>>>>>>>>>>>>>>>>>>>> simulation performed by H0(Infinite_Loop) (i.e.
> >>>>>>>>>>>>>>>>>>>>> your basis for correctness) does not halt
> >>>>>>>>>>>>>>>>>>>>> because H0 does not perform a correct and
> >>>>>>>>>>>>>>>>>>>>> complete simulation.
> >>>>>>>>>>>>>>>>>>>> This is what I mean by H evaluating what its
> >>>>>>>>>>>>>>>>>>>> correct and complete simulation of its input
> >>>>>>>>>>>>>>>>>>>> would be:
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> void P(ptr x)
> >>>>>>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>>>>> int Halt_Status = Simulate(x, x);
> >>>>>>>>>>>>>>>>>>>> if (Halt_Status)
> >>>>>>>>>>>>>>>>>>>> HERE: goto HERE;
> >>>>>>>>>>>>>>>>>>>> return;
> >>>>>>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> Although H itself does not perform a correct and
> >>>>>>>>>>>>>>>>>>>> complete simulation of non-halting inputs H does
> >>>>>>>>>>>>>>>>>>>> correctly predict that such a simulation would
> >>>>>>>>>>>>>>>>>>>> never halt.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> You changed the input from Pa to Pn.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> So you're again saying that Ha(Pa,Pa) reports the
> >>>>>>>>>>>>>>>>>>> halt status of the non-input Pn(Pn) instead of
> >>>>>>>>>>>>>>>>>>> Pa(Pa) as it is required to:
> >>>>>>>>>>>>>>>>>> H0(Infinite_Loop)
> >>>>>>>>>>>>>>>>>> reports on Simulate(Infinite_Loop)
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> H(Infinite_Recursion, 0x777)
> >>>>>>>>>>>>>>>>>> reports on Simulate((Infinite_Recursion, 0x777)
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> In every case a simulating halt decider reports on
> >>>>>>>>>>>>>>>>>> what the behavior of its simulated input would be
> >>>>>>>>>>>>>>>>>> if this SHD was swapped for a simulator.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> And in the case of Ha(Pa,Pa) you change the input in
> >>>>>>>>>>>>>>>>> doing so which is not allowed. Remember, what is
> >>>>>>>>>>>>>>>>> being decided on is the FIXED source code of Pa and
> >>>>>>>>>>>>>>>>> everything it calls, which includes the FIXED source
> >>>>>>>>>>>>>>>>> code of Ha and everything it calls.
> >>>>>>>>>>>>>>>> THIS JUST SEEMS OVER YOUR HEAD.
> >>>>>>>>>>>>>>>> H correctly determines that its input would never
> >>>>>>>>>>>>>>>> halt by correctly predicting that its input would
> >>>>>>>>>>>>>>>> never halt if H never aborted its simulation of this
> >>>>>>>>>>>>>>>> input.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Which is not what it is required to do if it claims to
> >>>>>>>>>>>>>>> be a halt decider:
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> For *any* algorithm X and input Y:
> >>>>>>>>>>>>>>> H(X,Y)==1 if and only if X(Y) halts, and
> >>>>>>>>>>>>>>> H(X,Y)==0 if and only if X(Y) does not halt
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>> This is based on the false assumption that the actual
> >>>>>>>>>>>>>> behavior of the actual input is the same behavior as
> >>>>>>>>>>>>>> X(Y).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> FALSE, because it is the behavior of the direct
> >>>>>>>>>>>>> execution that is being asked about.
> >>>>>>>>>>>> So you disagree that every decider must base its decision
> >>>>>>>>>>>> on a semantic or syntactic property of its input?
> >>>>>>>>>>>>
> >>>>>>>>>>>> In other words you are asserting that a decider must base
> >>>>>>>>>>>> its decision on a semantic or syntactic property of a
> >>>>>>>>>>>> non-input?
> >>>>>>>>>>>
> >>>>>>>>>>> You're the one asserting that, as you think that Ha(Pa,Pa)
> >>>>>>>>>>> should be reporting the halt status of Pn(Pn):
> >>>>>>>>>> A simulating halt decider always reports on what the
> >>>>>>>>>> behavior of its pure simulation of its input would be on
> >>>>>>>>>> the basis of recognizing an infinite behavior pattern that
> >>>>>>>>>> correctly predicts what the behavior of this pure
> >>>>>>>>>> simulation would be without the need to actually perform
> >>>>>>>>>> this pure simulation.
> >>>>>>>>>
> >>>>>>>>> Not when the infinite behaviour is a property of the decider
> >>>>>>>>> itself as
> >>>>>>>>
> >>>>>>>> It superficially seems like the behavior of H(P,P) is mutual
> >>>>>>>> infinite recursion until you realize the H is merely
> >>>>>>>> mimicking the behavior that P specifies.
> >>>>>>>
> >>>>>>> FALSE. P is NOT recursive, your H is recursive, this is
> >>>>>>> plainly obvious to everyone except you.
> >>>>>>
> >>>>>> My key unique discovery (back in 2016) was that every
> >>>>>> conventional "pathological" input used to prove that the HP
> >>>>>> cannot be solved specifies infinitely recursive simulation to
> >>>>>> every simulating halt decider.
> >>>>>
> >>>>> WRONG YOU OBTUSE FUCKING FUCKTARD. I HAVE DESIGNED A SIMULATING
> >>>>> HALT DECIDER THAT IS NOT INFINITELY RECURSIVE. HOW MANY MORE
> >>>>> TIMES DO I HAVE TO TELL YOU THIS BEFORE IT SINKS IN?
> >>>>>
> >>>>> /FLIBBLE
> >>>>>
> >>>>
> >>>> Yet the behavior of your "simulation" of its
> >>>> input is incorrect in that it does not correspond
> >>>> to the beahavior that P actually specifies.
> >>>>
> >>>> P does not specify that its simulation is supposed
> >>>> to be forked off into two different processes.
> >>>
> >>> P doesn't "have a simulation", a crucial point you keep missing, P
> >>> doesn't care what kind of decider H is. Also my SHD does not fork
> >>> off into "two different processes", the *simulation* is forked and
> >>> P is totally unaware that that has happened, which IMO is a
> >>> perfectly legit, original approach to the problem.
> >>>
> >>> /Flibble
> >>>
> >>
> >> Yet you cannot even specify the code for the "if statement" that
> >> determines that it should do this.
> >>
> >> if (some how some way the halt decider determines that its input
> >> halts) report halting
> >> else if (some how some way the halt decider determines that its
> >> input does not halt)
> >> report non-halting
> >> else
> >> report pathological input
> >
> > I only need to specify code if I was to actually implement it.
>
> What you have done is the same as if I said:
> "I have a cure for cancer" where my "cure" is:
> (1) Find a cure for cancer
> (2) Then we have a cure for cancer.

Not at all. I have presented a top-level design for it; I have no need
to present a detailed design unless I actually intend to implement it.

>
> > Implementing a simulating halt decider is not particularly hard:
> > detecting halting is trivial and detecting non-halting is done by
> > detecting duplication of the finite machine state
>
> Which is the most important part and you did not
> even do this in the simplest possible case:

What do you mean "I did not do"? I recall posting several different
ways of code being unreachable which is more than you have done.

/Flibble