On 11/12/22 11:02 AM, olcott wrote:
> On 11/12/2022 9:46 AM, Richard Damon wrote:
>> On 11/12/22 10:27 AM, olcott wrote:
>>> On 11/12/2022 8:58 AM, Richard Damon wrote:
>>>> On 11/12/22 9:35 AM, olcott wrote:
>>>>> On 11/12/2022 8:31 AM, Mr Flibble wrote:
>>>>>> On Sat, 12 Nov 2022 09:15:04 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 11/12/22 12:35 AM, olcott wrote:
>>>>>>>> On 11/11/2022 8:31 PM, Sergi o wrote:
>>>>>>>>> On 11/11/2022 8:21 PM, olcott wrote:
>>>>>>>>>> On 11/11/2022 1:56 PM, Jeff Barnett wrote:
>>>>>>>>>>> On 11/11/2022 11:43 AM, Richard Damon wrote:
>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I would
>>>>>>>>>>>>> have thought given your intelligence you would also understand
>>>>>>>>>>>>> that.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> I don't think he has actually blocked me, just mostly ignores
>>>>>>>>>>>> me.
>>>>>>>>>>>>
>>>>>>>>>>>> I say this because at times he seems to respond to what I say,
>>>>>>>>>>>> even if not in a direct reply,
>>>>>>>>>>>>
>>>>>>>>>>>> Also, when someone like you replies, even if he has blocked me,
>>>>>>>>>>>> he will still see me.
>>>>>>>>>>>>
>>>>>>>>>>>> More importantly, If anyone naive wanders into the archives, I
>>>>>>>>>>>> want enough evidence to be around to point out his errors.
>>>>>>>>>>>
>>>>>>>>>>> How is that working? Do you really think that repeating yourself
>>>>>>>>>>> literally 1000's of times makes good reading? Almost anyone who
>>>>>>>>>>> can look deeply enough into the logic will notice you engaging
>>>>>>>>>>> in a supposed dialogue with a stone wall (actually a stone
>>>>>>>>>>> brain). After your first half dozen messages a few years ago,
>>>>>>>>>>> you have added nothing to the conversation. Time to move on.
>>>>>>>>>>>> Note also, my longer replies shows what I know and provide
>>>>>>>>>>>> reasoning behind the claims, showing the Truth.
>>>>>>>>>>>
>>>>>>>>>>> It's a trivial truth and few will be fooled. Further, the real
>>>>>>>>>>> truth tellers and teachers do not hang out in these groups or
>>>>>>>>>>> archives. Too many truth tellers too few acolytes shrewd enough
>>>>>>>>>>> to know who has the inside track on god's word. Did you know
>>>>>>>>>>> that PO, in his less lucid moments, thinks he's a truth teller
>>>>>>>>>>> too? Truth tellers only pass the word when they preach to the
>>>>>>>>>>> choir.
>>>>>>>>>>>> His short claims, and guff replies just show that he doesn't
>>>>>>>>>>>> actually know what he is talking about, and reveals his
>>>>>>>>>>>> ignorance. If he tries to put his explanation into explicit
>>>>>>>>>>>> words, his errors become very apparent, I think even to him, so
>>>>>>>>>>>> he just refuses.
>>>>>>>>>>>
>>>>>>>>>>> So what? Rather than save the world from a babbling idiot, why
>>>>>>>>>>> not rescue homeless puppies at risk? You would be doing a better
>>>>>>>>>>> thing and would be more admired. A mathematical social worker is
>>>>>>>>>>> not needed.
>>>>>>>>>>>
>>>>>>>>>>> I think, instead, you don't know what to do with your time and
>>>>>>>>>>> have select this task to fill the gaps. Anyone studying the
>>>>>>>>>>> archives will notice that PO is the clear victor in all these
>>>>>>>>>>> threads. His head is too thick to be bothered by facts or
>>>>>>>>>>> sort-of facts; he's too ignorant and proud to be bothered by
>>>>>>>>>>> anyone else's facts or religion; and some of your presentations
>>>>>>>>>>> (articles) are not worded in the best way or are slightly
>>>>>>>>>>> misleading to someone who doesn't already know most of what you
>>>>>>>>>>> meant to say. (That's a problem with most of us writing articles
>>>>>>>>>>> without a few hours reflection before posting.) You will not win
>>>>>>>>>>> this way.
>>>>>>>>>>>
>>>>>>>>>>> Since I think you seek recognition for your efforts as a white
>>>>>>>>>>> knight and it's not working, I suggest you go black hat! Beat PO
>>>>>>>>>>> at his own game: Initiate threads five to twenty times a week;
>>>>>>>>>>> Have response chains where you respond significant numbers of
>>>>>>>>>>> times to your own articles; Be outrageous!
>>>>>>>>>>>
>>>>>>>>>>> This will only work if you devote enough time to take all of the
>>>>>>>>>>> PO USENET distinctions away from him. You must, every month, win
>>>>>>>>>>> the honors for (1) most threads started, (2) most number of
>>>>>>>>>>> responses to threads you have started, (3) most posts by an
>>>>>>>>>>> individual, (4) threads with largest number of indentations, (5)
>>>>>>>>>>> the highest number of almost repetitious posts - slight
>>>>>>>>>>> variations required, (6) highest percentage of silly
>>>>>>>>>>> capitalization, and (7) most times breaking USENET rules on text
>>>>>>>>>>> postings.
>>>>>>>>>>>
>>>>>>>>>>> When you follow the above seven point program (and you are well
>>>>>>>>>>> on your way in many of the points) you will eclipse PO and he
>>>>>>>>>>> will go POOF into a heap of dust. You will have won! At last.
>>>>>>>>>>> and history and the titles will be yours. You will be known to
>>>>>>>>>>> future USENET generations, for as long as the archives are
>>>>>>>>>>> maintained, as a winner.
>>>>>>>>>>>
>>>>>>>>>>> However, and this is an important however, you will have
>>>>>>>>>>> approximately the same impact on the truth as you do now. Why
>>>>>>>>>>> not have fun instead?
>>>>>>>>>>
>>>>>>>>>> I made the basis of my proof much easier to understand so that
>>>>>>>>>> anyone that is an expert in the C programming language would be
>>>>>>>>>> able to understand a simulating halt decider.
>>>>>>>>>>
>>>>>>>>>> void E(void (*x)())
>>>>>>>>>> {
>>>>>>>>>>     H(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> When H(D,D) returns 0 it correctly predicts that D correctly
>>>>>>>>>> simulated by H would never reach its own final state and
>>>>>>>>>> terminate normally after 1 to ∞ of correct simulation.
>>>>>>>>>>
>>>>>>>>>> I predict that no one will be able to find any actual error with
>>>>>>>>>> that.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> if it doesn't bust the compiler, run it through a code checker,
>>>>>>>>> lots of free ones out there
>>>>>>>>>
>>>>>>>>> https://www.onlinegdb.com/online_c_compiler
>>>>>>>>
>>>>>>>>
>>>>>>>> The last remaining issue is the acceptance of the notion of a
>>>>>>>> simulating halt decider.
>>>>>>>
>>>>>>> Why, It is actually a well know concept, as a PARTIAL solution of
>>>>>>> the
>>>>>>> problem.
>>>>>>>
>>>>>>> I remember it being shown as why you CAN'T just solve the problem
>>>>>>> with one.
>>>>>>>
>>>>>>> Your ignorance of the history of this topic has doomed you to repeat
>>>>>>> all the errors that others have made in the past.
>>>>>>
>>>>>> A simulating halt decider is Olcott's idea.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> Thanks. I was thinking about filing a trademark on it.
>>>>>
>>>>
>>>> Go ahead and waste your money.
>>>>
>>>> I remember the discussion of trying to determine halting by
>>>> simulation back in my school days, so not a new concept. Normally
>>>> showing the simple reasons about why it doesn't work.
>>>>
>>>
>>> What you are remembering is that a halt decider cannot correctly
>>> determine the halt status of an input by only simulating this input
>>> because some inputs never terminate.
>>>
>>> A simulating halt decider simulates its input in debug step mode and
>>> examines the execution trace of this input for non-halting behavior
>>> patterns.
>>
>> And it has been well known that non-halting does not have a finite set
>> of cases that always detect it.
> void Infinite_Loop()
> {
>   HERE: goto HERE;
> }
>
> void E(void (*x)())
> {
>   H(x, x);
> }
>
> It is an easily verified fact that Infinite_Loop and E are correctly
> recognized as specifying non-halting behavior to H.
>
>

On 11/12/2022 9:06 AM, Richard Damon wrote:
> On 11/12/22 9:43 AM, olcott wrote:
>> On 11/12/2022 8:02 AM, Richard Damon wrote:
>>> On 11/11/22 11:00 PM, olcott wrote:
>>>> On 11/11/2022 8:56 PM, Richard Damon wrote:
>>>>> On 11/11/22 9:48 PM, olcott wrote:
>>>>>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>>>>>> On 11/11/22 9:35 PM, olcott wrote:
>>>>>
>>>>>> Yes and when embedded_H can predict this in a finite number of
>>>>>> steps then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>
>>>>>
>>>>> Except that it can't do that since it is shown that H^ <H^> Will
>>>>> halt in this case, so it is impossible to correctly predict that a
>>>>> correct simulation of the input <H^> <H^> will not halt.
>>>> A simulating halt decider must correctly predict (in a finite number
>>>> of steps whether or not its simulated input would ever stop running
>>>> if it never aborted its simulation of its input.
>>>>
>>>>
>>>
>>> Right, it must, but it can't. Again, your Egish is lacking because
>>> you are too stupid.
>>>
>>> If you claim it can, what pattern did it use to detect this, that
>>> ALWAYS shows the program is non-halting?
>>>
>>> I will note that E(E) calling H(E,E) is NOT such a pattern, as E(E)
>>> will halt if H(E,E) is defined to abort that simulation and return 0.
>> void Infinite_Loop()
>> {
>>    HERE: goto HERE;
>> }
>>
>> It is an easily verified fact that Infinite_Loop correctly simulated
>> by H would never reach its own last instruction and terminate normally
>> after 1 to ∞ steps of correct simulation.
>>
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>> It is an easily verified fact that E correctly simulated by H would
>> never reach its own last instruction and terminate normally after 1 to
>> ∞ steps of correct simulation.
>>
>>
>
> Then verify it. Hard to do since E(E) does halt since H(E,E) returns 0.
>
E correctly simulated by H
E correctly simulated by H
E correctly simulated by H
E correctly simulated by H
E correctly simulated by H

would never reach its own last instruction and terminate normally after
1 to ∞ steps of correct simulation.

Since you know this is true I don't see why you continue to lie about it.

When H(E,E) returns 0 it is correctly rejecting its input on the basis
that E correctly simulated by H would never reach its own last
instruction and terminate normally after 1 to ∞ steps of correct simulation.

The definition of a UTM specifies that the correct simulation of a
machine description provides the actual behavior specified by this
machine description thus H is correct to base its halt status decision
on E correctly simulated by H.

--
Copyright 2022 Pete Olcott "Talent hits a target no one else can hit;
Genius hits a target no one else can see." Arthur Schopenhauer

On 11/12/22 11:06 AM, olcott wrote:
> On 11/12/2022 9:26 AM, Richard Damon wrote:
>> On 11/12/22 10:03 AM, Mr Flibble wrote:
>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>> and I would have thought given your intelligence you
>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>> halt. Note, such an H doesn't do a correct simulation, so any
>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>
>>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>>> wrong is the mapping of the need to abort the simulation to a
>>>>>>>>>>> halt decision of non-halting; it needs to instead be mapped to
>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>
>>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>>> directly express a reference.
>>>>>>>>>
>>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>>> all the way down so is the same category error manifesting in a
>>>>>>>>> different way.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>>> actually a decider.
>>>>>>>>
>>>>>>>> If we assume a prospective decider exists, then the "Impossible"
>>>>>>>> program is simple to make from it, and is given one copy of the
>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>
>>>>>>>> When run it makes a second copy of its description, and then
>>>>>>>> calls the decider.
>>>>>>>>
>>>>>>>> After that, it is the deciders job to make the decision in finite
>>>>>>>> time, by whatever method it wants. If it gets stuck in your
>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>
>>>>>>>> The proof shows that what ever answer the decider does give (if
>>>>>>>> it gives one) will be wrong, and thus the decider doesn't meet
>>>>>>>> the requirements.
>>>>>>>>
>>>>>>>> No "Self Reference" in sight there only a program being given a
>>>>>>>> copy of something that just happens to be its own description.
>>>>>>>>
>>>>>>>> The only place we get any form of "Reference", is when we try to
>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge. There the
>>>>>>>> effect of the Self-Reference just lets us see that the task turns
>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>
>>>>>>> You are fractally wrong on all fronts: in the traditional halting
>>>>>>> problem proofs based on [Strachey 1965] the program is impossible
>>>>>>> not due to self reference or infinite copies but because the input
>>>>>>> tries to do the opposite of what the decider decides; the category
>>>>>>> error that I have identified is different: it is an error of self
>>>>>>> reference and/or infinite copies; it is an error related to the
>>>>>>> fact that the input references a decider rather than being related
>>>>>>> to what the input does with the decision result of a decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>> Strachey's program. The decider is SUPPOSED to be able to handle
>>>>>> ANY input and answer in finite time, If an input causes it to make
>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>> requirements.
>>>>>>
>>>>>> Turing Machine can ALWAYS be legally built based on another Turing
>>>>>> Machine as a base. The only reason it wouldn't be allowed is if H
>>>>>> isn't actually a Turing Machine, so it CAN'T be a category error
>>>>>> if H is actualy a Turing Machine.
>>>>>>
>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>> admitting that your H can't actually be a Turing Machine, but must
>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>> requirement to be the needed decider.
>>>>>
>>>>> In which case we get infinite turning machines all the way down: yet
>>>>> another manifestation of the category error I have identified.
>>>>>
>>>>> /Flibble
>>>>
>>>> Where are infinite machines? There is ONE machine being run, either H
>>>> or D, and it SIMULATING others, and if we get an infinite sequence of
>>>> simulations we have just shown that H was defective because it failed
>>>> to answer in finite time.
>>>>
>>>> This isn't a category error, but a design error in H.
>>>>
>>>> Note, when we start H, there is exactly two machines present in
>>>> representation on the tape, and two is much smaller than infinity.
>>>
>>> Nope, if,
>>>
>>> a) H is a copy, and
>>> b) H is a Turing Machine, and
>>> c) D is an input into H, and
>>> d) D references H, and
>>> e) H references D,
>>>
>>> then (d) and (e) repeat ad infinitum so we get infinite Turing Machines
>>> all the way down: a manifestation of the category error I have
>>> identified.
>>>
>>> /Flibble
>>>
>>
>> H doesn't reference D, in fact it CAN'T because D doesn't exist when H
>> is created. You can't actually reference something that doesn't exist.
> void D(void (*x)())
> {
>   int Halt_Status = H(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return;
> }
>
> So if I smash a Boston cream pie in your face you will say blub, blub
> blub (speaking through pie dripping from your face) there is no pie.
>

On 11/12/22 10:50 AM, olcott wrote:
> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>> On Sat, 12 Nov 2022 09:52:12 -0500
>> Richard Damon <Richard@Damon-Family.org> wrote:
>>
>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>> and I would have thought given your intelligence you
>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>
>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>> halt. Note, such an H doesn't do a correct simulation, so any
>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>
>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>> wrong is the mapping of the need to abort the simulation to a
>>>>>>>>>> halt decision of non-halting; it needs to instead be mapped to
>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Nope, no self reference.
>>>>>>>>>
>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>> directly express a reference.
>>>>>>>>
>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>> all the way down so is the same category error manifesting in a
>>>>>>>> different way.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>> actually a decider.
>>>>>>>
>>>>>>> If we assume a prospective decider exists, then the "Impossible"
>>>>>>> program is simple to make from it, and is given one copy of the
>>>>>>> description of itself, which is also simple to make.
>>>>>>>
>>>>>>> When run it makes a second copy of its description, and then
>>>>>>> calls the decider.
>>>>>>>
>>>>>>> After that, it is the deciders job to make the decision in finite
>>>>>>> time, by whatever method it wants. If it gets stuck in your
>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>
>>>>>>> The proof shows that what ever answer the decider does give (if
>>>>>>> it gives one) will be wrong, and thus the decider doesn't meet
>>>>>>> the requirements.
>>>>>>>
>>>>>>> No "Self Reference" in sight there only a program being given a
>>>>>>> copy of something that just happens to be its own description.
>>>>>>>
>>>>>>> The only place we get any form of "Reference", is when we try to
>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge. There the
>>>>>>> effect of the Self-Reference just lets us see that the task turns
>>>>>>> out be be impossible, so no such program exists.
>>>>>>
>>>>>> You are fractally wrong on all fronts: in the traditional halting
>>>>>> problem proofs based on [Strachey 1965] the program is impossible
>>>>>> not due to self reference or infinite copies but because the input
>>>>>> tries to do the opposite of what the decider decides; the category
>>>>>> error that I have identified is different: it is an error of self
>>>>>> reference and/or infinite copies; it is an error related to the
>>>>>> fact that the input references a decider rather than being related
>>>>>> to what the input does with the decision result of a decider.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> But the infinite copies is a error in the Decider, not in
>>>>> Strachey's program. The decider is SUPPOSED to be able to handle
>>>>> ANY input and answer in finite time, If an input causes it to make
>>>>> infinite copies, then the decided just doesn't meet its
>>>>> requirements.
>>>>>
>>>>> Turing Machine can ALWAYS be legally built based on another Turing
>>>>> Machine as a base. The only reason it wouldn't be allowed is if H
>>>>> isn't actually a Turing Machine, so it CAN'T be a category error
>>>>> if H is actualy a Turing Machine.
>>>>>
>>>>> All your declaration of a "Category Error" here is doing is
>>>>> admitting that your H can't actually be a Turing Machine, but must
>>>>> be of a HIGHER order logic system, which means H fails the
>>>>> requirement to be the needed decider.
>>>>
>>>> In which case we get infinite turning machines all the way down: yet
>>>> another manifestation of the category error I have identified.
>>>>
>>>> /Flibble
>>>
>>> Where are infinite machines? There is ONE machine being run, either H
>>> or D, and it SIMULATING others, and if we get an infinite sequence of
>>> simulations we have just shown that H was defective because it failed
>>> to answer in finite time.
>>>
>>> This isn't a category error, but a design error in H.
>>>
>>> Note, when we start H, there is exactly two machines present in
>>> representation on the tape, and two is much smaller than infinity.
>>
>> Nope, if,
>>
>> a) H is a copy, and
>> b) H is a Turing Machine, and
>> c) D is an input into H, and
>> d) D references H, and
>> e) H references D,
>>
>> then (d) and (e) repeat ad infinitum so we get infinite Turing Machines
>> all the way down: a manifestation of the category error I have
>> identified.
>>
>> /Flibble
>>
>
> void E(void (*x)())
> {
>   H(x, x);
> }
>
> The point is
> that D correctly simulated by H would never reach its own last
> instruction and terminate normally after 1 to ∞ steps of correct
> simulation.
>
> When H returns 0 to main() it is indicating
>
> that D correctly simulated by H would never reach its own last
> instruction and terminate normally after 1 to ∞ steps of correct
> simulation.
>

On Sat, 12 Nov 2022 11:09:56 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/12/22 10:52 AM, Mr Flibble wrote:
> > On Sat, 12 Nov 2022 10:41:58 -0500
> > Richard Damon <Richard@Damon-Family.org> wrote:
> >
> >> On 11/12/22 10:16 AM, Mr Flibble wrote:
> >>> On Sat, 12 Nov 2022 09:58:47 -0500
> >>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>
> >>>> On 11/12/22 9:35 AM, olcott wrote:
> >>>>> On 11/12/2022 8:31 AM, Mr Flibble wrote:
> >>>>>> On Sat, 12 Nov 2022 09:15:04 -0500
> >>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>
> >>>>>>> On 11/12/22 12:35 AM, olcott wrote:
> >>>>>>>> On 11/11/2022 8:31 PM, Sergi o wrote:
> >>>>>>>>> On 11/11/2022 8:21 PM, olcott wrote:
> >>>>>>>>>> On 11/11/2022 1:56 PM, Jeff Barnett wrote:
> >>>>>>>>>>> On 11/11/2022 11:43 AM, Richard Damon wrote:
> >>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
> >>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
> >>>>>>>>>>>>> would have thought given your intelligence you would
> >>>>>>>>>>>>> also understand that.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>
> >>>>>>>>>>>> I don't think he has actually blocked me, just mostly
> >>>>>>>>>>>> ignores me.
> >>>>>>>>>>>>
> >>>>>>>>>>>> I say this because at times he seems to respond to what I
> >>>>>>>>>>>> say, even if not in a direct reply,
> >>>>>>>>>>>>
> >>>>>>>>>>>> Also, when someone like you replies, even if he has
> >>>>>>>>>>>> blocked me, he will still see me.
> >>>>>>>>>>>>
> >>>>>>>>>>>> More importantly, If anyone naive wanders into the
> >>>>>>>>>>>> archives, I want enough evidence to be around to point
> >>>>>>>>>>>> out his errors.
> >>>>>>>>>>>
> >>>>>>>>>>> How is that working? Do you really think that repeating
> >>>>>>>>>>> yourself literally 1000's of times makes good reading?
> >>>>>>>>>>> Almost anyone who can look deeply enough into the logic
> >>>>>>>>>>> will notice you engaging in a supposed dialogue with a
> >>>>>>>>>>> stone wall (actually a stone brain). After your first half
> >>>>>>>>>>> dozen messages a few years ago, you have added nothing to
> >>>>>>>>>>> the conversation. Time to move on.
> >>>>>>>>>>>> Note also, my longer replies shows what I know and
> >>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
> >>>>>>>>>>>
> >>>>>>>>>>> It's a trivial truth and few will be fooled. Further, the
> >>>>>>>>>>> real truth tellers and teachers do not hang out in these
> >>>>>>>>>>> groups or archives. Too many truth tellers too few
> >>>>>>>>>>> acolytes shrewd enough to know who has the inside track
> >>>>>>>>>>> on god's word. Did you know that PO, in his less lucid
> >>>>>>>>>>> moments, thinks he's a truth teller too? Truth tellers
> >>>>>>>>>>> only pass the word when they preach to the choir.
> >>>>>>>>>>>> His short claims, and guff replies just show that he
> >>>>>>>>>>>> doesn't actually know what he is talking about, and
> >>>>>>>>>>>> reveals his ignorance. If he tries to put his explanation
> >>>>>>>>>>>> into explicit words, his errors become very apparent, I
> >>>>>>>>>>>> think even to him, so he just refuses.
> >>>>>>>>>>>
> >>>>>>>>>>> So what? Rather than save the world from a babbling idiot,
> >>>>>>>>>>> why not rescue homeless puppies at risk? You would be
> >>>>>>>>>>> doing a better thing and would be more admired. A
> >>>>>>>>>>> mathematical social worker is not needed.
> >>>>>>>>>>>
> >>>>>>>>>>> I think, instead, you don't know what to do with your time
> >>>>>>>>>>> and have select this task to fill the gaps. Anyone
> >>>>>>>>>>> studying the archives will notice that PO is the clear
> >>>>>>>>>>> victor in all these threads. His head is too thick to be
> >>>>>>>>>>> bothered by facts or sort-of facts; he's too ignorant and
> >>>>>>>>>>> proud to be bothered by anyone else's facts or religion;
> >>>>>>>>>>> and some of your presentations (articles) are not worded
> >>>>>>>>>>> in the best way or are slightly misleading to someone who
> >>>>>>>>>>> doesn't already know most of what you meant to say.
> >>>>>>>>>>> (That's a problem with most of us writing articles
> >>>>>>>>>>> without a few hours reflection before posting.) You will
> >>>>>>>>>>> not win this way.
> >>>>>>>>>>>
> >>>>>>>>>>> Since I think you seek recognition for your efforts as a
> >>>>>>>>>>> white knight and it's not working, I suggest you go black
> >>>>>>>>>>> hat! Beat PO at his own game: Initiate threads five to
> >>>>>>>>>>> twenty times a week; Have response chains where you
> >>>>>>>>>>> respond significant numbers of times to your own
> >>>>>>>>>>> articles; Be outrageous!
> >>>>>>>>>>>
> >>>>>>>>>>> This will only work if you devote enough time to take all
> >>>>>>>>>>> of the PO USENET distinctions away from him. You must,
> >>>>>>>>>>> every month, win the honors for (1) most threads started,
> >>>>>>>>>>> (2) most number of responses to threads you have started,
> >>>>>>>>>>> (3) most posts by an individual, (4) threads with largest
> >>>>>>>>>>> number of indentations, (5) the highest number of almost
> >>>>>>>>>>> repetitious posts - slight variations required, (6)
> >>>>>>>>>>> highest percentage of silly capitalization, and (7) most
> >>>>>>>>>>> times breaking USENET rules on text postings.
> >>>>>>>>>>>
> >>>>>>>>>>> When you follow the above seven point program (and you are
> >>>>>>>>>>> well on your way in many of the points) you will eclipse
> >>>>>>>>>>> PO and he will go POOF into a heap of dust. You will have
> >>>>>>>>>>> won! At last. and history and the titles will be yours.
> >>>>>>>>>>> You will be known to future USENET generations, for as
> >>>>>>>>>>> long as the archives are maintained, as a winner.
> >>>>>>>>>>>
> >>>>>>>>>>> However, and this is an important however, you will have
> >>>>>>>>>>> approximately the same impact on the truth as you do now.
> >>>>>>>>>>> Why not have fun instead?
> >>>>>>>>>>
> >>>>>>>>>> I made the basis of my proof much easier to understand so
> >>>>>>>>>> that anyone that is an expert in the C programming language
> >>>>>>>>>> would be able to understand a simulating halt decider.
> >>>>>>>>>>
> >>>>>>>>>> void E(void (*x)())
> >>>>>>>>>> {
> >>>>>>>>>>     H(x, x);
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> When H(D,D) returns 0 it correctly predicts that D
> >>>>>>>>>> correctly simulated by H would never reach its own final
> >>>>>>>>>> state and terminate normally after 1 to ∞ of correct
> >>>>>>>>>> simulation.
> >>>>>>>>>>
> >>>>>>>>>> I predict that no one will be able to find any actual error
> >>>>>>>>>> with that.
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> if it doesn't bust the compiler, run it through a code
> >>>>>>>>> checker, lots of free ones out there
> >>>>>>>>>
> >>>>>>>>> https://www.onlinegdb.com/online_c_compiler
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> The last remaining issue is the acceptance of the notion of a
> >>>>>>>> simulating halt decider.
> >>>>>>>
> >>>>>>> Why, It is actually a well know concept, as a PARTIAL solution
> >>>>>>> of the problem.
> >>>>>>>
> >>>>>>> I remember it being shown as why you CAN'T just solve the
> >>>>>>> problem with one.
> >>>>>>>
> >>>>>>> Your ignorance of the history of this topic has doomed you to
> >>>>>>> repeat all the errors that others have made in the past.
> >>>>>>
> >>>>>> A simulating halt decider is Olcott's idea.
> >>>>>>
> >>>>>> /Flibble
> >>>>>>
> >>>>>
> >>>>> Thanks. I was thinking about filing a trademark on it.
> >>>>>
> >>>>
> >>>> Go ahead and waste your money.
> >>>>
> >>>> I remember the discussion of trying to determine halting by
> >>>> simulation back in my school days, so not a new concept. Normally
> >>>> showing the simple reasons about why it doesn't work.
> >>>>
> >>>> Note, this is pre-internet, so your Google searches not bringing
> >>>> it up is understandable.
> >>>>
> >>>> Likely didn't reach "published papers" as it was a well known
> >>>> dead end so no need to write the paper.
> >>>
> >>> So you have no evidence to backup that claim. So no prior art
> >>> leaving Olcott free to trademark or file a patent.
> >>>
> >>> /Flibble
> >>>
> >>
> >> He can't file a patent, as he has publicly disclosed the idea too
> >> long ago. Public disclosure precludes later patent. If he filed a
> >> preliminary patent BEFORE disclosure, he is given a limited amount
> >> of time to finalize it, but I think too much time has passed now
> >> for that to be an option.
> >>
> >> There is also the problem tha that you need to demonstrate that it
> >> works.
> >
> > You are obviously unaware of the USPTO which allows patent trolls to
> > file vague nebulous patents all the time that are certainly not
> > "demonstrated to work". Patent trolls don't make money by creating
> > patented product, they make money through litigation if they think
> > their vague patents can be asserted in a congenial legal district.
> >
> > /Flibble
> >
>
> And you are not aware that such patents can be declared invalid, and
> the trolls required to pay the legal fees of the chalenger if said
> patent is determined to have been fraudulently field.
>
> Yes, some trolls do get away with invalid patents because it isn't
> worth the effort.
>
> Note also, "work" doesn't need to be commercially viable, so can be a
> low standard in some fields.
>
> A patent must include a sample implementation of the invention it
> claims, and claims about what that implementation can do. "Lying"
> about that ability invalidates the patent.

On 11/12/22 11:20 AM, olcott wrote:
> On 11/12/2022 9:06 AM, Richard Damon wrote:
>> On 11/12/22 9:43 AM, olcott wrote:
>>> On 11/12/2022 8:02 AM, Richard Damon wrote:
>>>> On 11/11/22 11:00 PM, olcott wrote:
>>>>> On 11/11/2022 8:56 PM, Richard Damon wrote:
>>>>>> On 11/11/22 9:48 PM, olcott wrote:
>>>>>>> On 11/11/2022 8:45 PM, Richard Damon wrote:
>>>>>>>> On 11/11/22 9:35 PM, olcott wrote:
>>>>>>
>>>>>>> Yes and when embedded_H can predict this in a finite number of
>>>>>>> steps then it is a halt decider for ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>>>>>
>>>>>>
>>>>>> Except that it can't do that since it is shown that H^ <H^> Will
>>>>>> halt in this case, so it is impossible to correctly predict that a
>>>>>> correct simulation of the input <H^> <H^> will not halt.
>>>>> A simulating halt decider must correctly predict (in a finite
>>>>> number of steps whether or not its simulated input would ever stop
>>>>> running if it never aborted its simulation of its input.
>>>>>
>>>>>
>>>>
>>>> Right, it must, but it can't. Again, your Egish is lacking because
>>>> you are too stupid.
>>>>
>>>> If you claim it can, what pattern did it use to detect this, that
>>>> ALWAYS shows the program is non-halting?
>>>>
>>>> I will note that E(E) calling H(E,E) is NOT such a pattern, as E(E)
>>>> will halt if H(E,E) is defined to abort that simulation and return 0.
>>> void Infinite_Loop()
>>> {
>>>    HERE: goto HERE;
>>> }
>>>
>>> It is an easily verified fact that Infinite_Loop correctly simulated
>>> by H would never reach its own last instruction and terminate
>>> normally after 1 to ∞ steps of correct simulation.
>>>
>>> void E(void (*x)())
>>> {
>>>    H(x, x);
>>> }
>>>
>>> It is an easily verified fact that E correctly simulated by H would
>>> never reach its own last instruction and terminate normally after 1
>>> to ∞ steps of correct simulation.
>>>
>>>
>>
>> Then verify it. Hard to do since E(E) does halt since H(E,E) returns 0.
>>
> E correctly simulated by H
> E correctly simulated by H
> E correctly simulated by H
> E correctly simulated by H
> E correctly simulated by H

Which is a STRAWMAN, or is H not a Halt Decider,

A Halt Decider needs to decide on the direct exectution of the input, or
the input simulated by a UTM, which, by definition, never aborts its
simulation, so H isn't a UTM.

FAIL.

>
> would never reach its own last instruction and terminate normally after
> 1 to ∞ steps of correct simulation.
>
> Since you know this is true I don't see why you continue to lie about it.

No, you THINK that Strawman statement is a usable basis, but it isn't.

You are just proving your stupidity by repeating it.

>
> When H(E,E) returns 0 it is correctly rejecting its input on the basis
> that E correctly simulated by H would never reach its own last
> instruction and terminate normally after 1 to ∞ steps of correct
> simulation.
>
> The definition of a UTM specifies that the correct simulation of a
> machine description provides the actual behavior specified by this
> machine description thus H is correct to base its halt status decision
> on E correctly simulated by H.
>
>

Except H isn't a UTM. H can base its answer on what a UTM would do when
simulating the input, but since H isn't a UTM, it can't use itself.

UTM(E,E) will see E call H(E,E), then H simulating E(E) until it sees it
call H(E,E) again, and then abort its simulation and return 0 to E and
then E halt.

Ths the correct answer is HALTING.

You are just showing you just fundamentally don't understand even the
basics of the field you are talking about, showing your stupidity. This
incompetence is of such a high magnatude, it seems that you are likely a
pathological liar to not be able to see the errors in your logic,
totally unable to tell the difference between truth and error.

On 11/12/2022 10:26 AM, Richard Damon wrote:
> On 11/12/22 10:50 AM, olcott wrote:
>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>> and I would have thought given your intelligence you
>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>
>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>> halt. Note, such an H doesn't do a correct simulation, so any
>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>
>>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>>> wrong is the mapping of the need to abort the simulation to a
>>>>>>>>>>> halt decision of non-halting; it needs to instead be mapped to
>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>
>>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>>> directly express a reference.
>>>>>>>>>
>>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>>> all the way down so is the same category error manifesting in a
>>>>>>>>> different way.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>>> actually a decider.
>>>>>>>>
>>>>>>>> If we assume a prospective decider exists, then the "Impossible"
>>>>>>>> program is simple to make from it, and is given one copy of the
>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>
>>>>>>>> When run it makes a second copy of its description, and then
>>>>>>>> calls the decider.
>>>>>>>>
>>>>>>>> After that, it is the deciders job to make the decision in finite
>>>>>>>> time, by whatever method it wants. If it gets stuck in your
>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>
>>>>>>>> The proof shows that what ever answer the decider does give (if
>>>>>>>> it gives one) will be wrong, and thus the decider doesn't meet
>>>>>>>> the requirements.
>>>>>>>>
>>>>>>>> No "Self Reference" in sight there only a program being given a
>>>>>>>> copy of something that just happens to be its own description.
>>>>>>>>
>>>>>>>> The only place we get any form of "Reference", is when we try to
>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge. There the
>>>>>>>> effect of the Self-Reference just lets us see that the task turns
>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>
>>>>>>> You are fractally wrong on all fronts: in the traditional halting
>>>>>>> problem proofs based on [Strachey 1965] the program is impossible
>>>>>>> not due to self reference or infinite copies but because the input
>>>>>>> tries to do the opposite of what the decider decides; the category
>>>>>>> error that I have identified is different: it is an error of self
>>>>>>> reference and/or infinite copies; it is an error related to the
>>>>>>> fact that the input references a decider rather than being related
>>>>>>> to what the input does with the decision result of a decider.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>> Strachey's program. The decider is SUPPOSED to be able to handle
>>>>>> ANY input and answer in finite time, If an input causes it to make
>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>> requirements.
>>>>>>
>>>>>> Turing Machine can ALWAYS be legally built based on another Turing
>>>>>> Machine as a base. The only reason it wouldn't be allowed is if H
>>>>>> isn't actually a Turing Machine, so it CAN'T be a category error
>>>>>> if H is actualy a Turing Machine.
>>>>>>
>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>> admitting that your H can't actually be a Turing Machine, but must
>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>> requirement to be the needed decider.
>>>>>
>>>>> In which case we get infinite turning machines all the way down: yet
>>>>> another manifestation of the category error I have identified.
>>>>>
>>>>> /Flibble
>>>>
>>>> Where are infinite machines? There is ONE machine being run, either H
>>>> or D, and it SIMULATING others, and if we get an infinite sequence of
>>>> simulations we have just shown that H was defective because it failed
>>>> to answer in finite time.
>>>>
>>>> This isn't a category error, but a design error in H.
>>>>
>>>> Note, when we start H, there is exactly two machines present in
>>>> representation on the tape, and two is much smaller than infinity.
>>>
>>> Nope, if,
>>>
>>> a) H is a copy, and
>>> b) H is a Turing Machine, and
>>> c) D is an input into H, and
>>> d) D references H, and
>>> e) H references D,
>>>
>>> then (d) and (e) repeat ad infinitum so we get infinite Turing Machines
>>> all the way down: a manifestation of the category error I have
>>> identified.
>>>
>>> /Flibble
>>>
>>
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>> The point is
>> that D correctly simulated by H would never reach its own last
>> instruction and terminate normally after 1 to ∞ steps of correct
>> simulation.
>>
>> When H returns 0 to main() it is indicating
>>
>> that D correctly simulated by H would never reach its own last
>> instruction and terminate normally after 1 to ∞ steps of correct
>> simulation.
>>
>
> Except D is NOT correctly simulated by H, so that is a incorrect
> statement. When it is correctly simulated by something other than H, it
> will come to a final state, showing your statement is wrong.
In order for the simulation to actually be incorrect the execution trace
of the simulated E must diverge from the behavior that the line-by-line
x86 source-code of E specifies.

On 11/12/2022 10:42 AM, Mr Flibble wrote:
> On Sat, 12 Nov 2022 11:09:56 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/12/22 10:52 AM, Mr Flibble wrote:
>>> On Sat, 12 Nov 2022 10:41:58 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/12/22 10:16 AM, Mr Flibble wrote:
>>>>> On Sat, 12 Nov 2022 09:58:47 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>
>>>>>> On 11/12/22 9:35 AM, olcott wrote:
>>>>>>> On 11/12/2022 8:31 AM, Mr Flibble wrote:
>>>>>>>> On Sat, 12 Nov 2022 09:15:04 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>
>>>>>>>>> On 11/12/22 12:35 AM, olcott wrote:
>>>>>>>>>> On 11/11/2022 8:31 PM, Sergi o wrote:
>>>>>>>>>>> On 11/11/2022 8:21 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 1:56 PM, Jeff Barnett wrote:
>>>>>>>>>>>>> On 11/11/2022 11:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>> would have thought given your intelligence you would
>>>>>>>>>>>>>>> also understand that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>
>>>>>>>>>>>>> How is that working? Do you really think that repeating
>>>>>>>>>>>>> yourself literally 1000's of times makes good reading?
>>>>>>>>>>>>> Almost anyone who can look deeply enough into the logic
>>>>>>>>>>>>> will notice you engaging in a supposed dialogue with a
>>>>>>>>>>>>> stone wall (actually a stone brain). After your first half
>>>>>>>>>>>>> dozen messages a few years ago, you have added nothing to
>>>>>>>>>>>>> the conversation. Time to move on.
>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It's a trivial truth and few will be fooled. Further, the
>>>>>>>>>>>>> real truth tellers and teachers do not hang out in these
>>>>>>>>>>>>> groups or archives. Too many truth tellers too few
>>>>>>>>>>>>> acolytes shrewd enough to know who has the inside track
>>>>>>>>>>>>> on god's word. Did you know that PO, in his less lucid
>>>>>>>>>>>>> moments, thinks he's a truth teller too? Truth tellers
>>>>>>>>>>>>> only pass the word when they preach to the choir.
>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his explanation
>>>>>>>>>>>>>> into explicit words, his errors become very apparent, I
>>>>>>>>>>>>>> think even to him, so he just refuses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So what? Rather than save the world from a babbling idiot,
>>>>>>>>>>>>> why not rescue homeless puppies at risk? You would be
>>>>>>>>>>>>> doing a better thing and would be more admired. A
>>>>>>>>>>>>> mathematical social worker is not needed.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I think, instead, you don't know what to do with your time
>>>>>>>>>>>>> and have select this task to fill the gaps. Anyone
>>>>>>>>>>>>> studying the archives will notice that PO is the clear
>>>>>>>>>>>>> victor in all these threads. His head is too thick to be
>>>>>>>>>>>>> bothered by facts or sort-of facts; he's too ignorant and
>>>>>>>>>>>>> proud to be bothered by anyone else's facts or religion;
>>>>>>>>>>>>> and some of your presentations (articles) are not worded
>>>>>>>>>>>>> in the best way or are slightly misleading to someone who
>>>>>>>>>>>>> doesn't already know most of what you meant to say.
>>>>>>>>>>>>> (That's a problem with most of us writing articles
>>>>>>>>>>>>> without a few hours reflection before posting.) You will
>>>>>>>>>>>>> not win this way.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since I think you seek recognition for your efforts as a
>>>>>>>>>>>>> white knight and it's not working, I suggest you go black
>>>>>>>>>>>>> hat! Beat PO at his own game: Initiate threads five to
>>>>>>>>>>>>> twenty times a week; Have response chains where you
>>>>>>>>>>>>> respond significant numbers of times to your own
>>>>>>>>>>>>> articles; Be outrageous!
>>>>>>>>>>>>>
>>>>>>>>>>>>> This will only work if you devote enough time to take all
>>>>>>>>>>>>> of the PO USENET distinctions away from him. You must,
>>>>>>>>>>>>> every month, win the honors for (1) most threads started,
>>>>>>>>>>>>> (2) most number of responses to threads you have started,
>>>>>>>>>>>>> (3) most posts by an individual, (4) threads with largest
>>>>>>>>>>>>> number of indentations, (5) the highest number of almost
>>>>>>>>>>>>> repetitious posts - slight variations required, (6)
>>>>>>>>>>>>> highest percentage of silly capitalization, and (7) most
>>>>>>>>>>>>> times breaking USENET rules on text postings.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When you follow the above seven point program (and you are
>>>>>>>>>>>>> well on your way in many of the points) you will eclipse
>>>>>>>>>>>>> PO and he will go POOF into a heap of dust. You will have
>>>>>>>>>>>>> won! At last. and history and the titles will be yours.
>>>>>>>>>>>>> You will be known to future USENET generations, for as
>>>>>>>>>>>>> long as the archives are maintained, as a winner.
>>>>>>>>>>>>>
>>>>>>>>>>>>> However, and this is an important however, you will have
>>>>>>>>>>>>> approximately the same impact on the truth as you do now.
>>>>>>>>>>>>> Why not have fun instead?
>>>>>>>>>>>>
>>>>>>>>>>>> I made the basis of my proof much easier to understand so
>>>>>>>>>>>> that anyone that is an expert in the C programming language
>>>>>>>>>>>> would be able to understand a simulating halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> When H(D,D) returns 0 it correctly predicts that D
>>>>>>>>>>>> correctly simulated by H would never reach its own final
>>>>>>>>>>>> state and terminate normally after 1 to ∞ of correct
>>>>>>>>>>>> simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> I predict that no one will be able to find any actual error
>>>>>>>>>>>> with that.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> if it doesn't bust the compiler, run it through a code
>>>>>>>>>>> checker, lots of free ones out there
>>>>>>>>>>>
>>>>>>>>>>> https://www.onlinegdb.com/online_c_compiler
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The last remaining issue is the acceptance of the notion of a
>>>>>>>>>> simulating halt decider.
>>>>>>>>>
>>>>>>>>> Why, It is actually a well know concept, as a PARTIAL solution
>>>>>>>>> of the problem.
>>>>>>>>>
>>>>>>>>> I remember it being shown as why you CAN'T just solve the
>>>>>>>>> problem with one.
>>>>>>>>>
>>>>>>>>> Your ignorance of the history of this topic has doomed you to
>>>>>>>>> repeat all the errors that others have made in the past.
>>>>>>>>
>>>>>>>> A simulating halt decider is Olcott's idea.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> Thanks. I was thinking about filing a trademark on it.
>>>>>>>
>>>>>>
>>>>>> Go ahead and waste your money.
>>>>>>
>>>>>> I remember the discussion of trying to determine halting by
>>>>>> simulation back in my school days, so not a new concept. Normally
>>>>>> showing the simple reasons about why it doesn't work.
>>>>>>
>>>>>> Note, this is pre-internet, so your Google searches not bringing
>>>>>> it up is understandable.
>>>>>>
>>>>>> Likely didn't reach "published papers" as it was a well known
>>>>>> dead end so no need to write the paper.
>>>>>
>>>>> So you have no evidence to backup that claim. So no prior art
>>>>> leaving Olcott free to trademark or file a patent.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> He can't file a patent, as he has publicly disclosed the idea too
>>>> long ago. Public disclosure precludes later patent. If he filed a
>>>> preliminary patent BEFORE disclosure, he is given a limited amount
>>>> of time to finalize it, but I think too much time has passed now
>>>> for that to be an option.
>>>>
>>>> There is also the problem tha that you need to demonstrate that it
>>>> works.
>>>
>>> You are obviously unaware of the USPTO which allows patent trolls to
>>> file vague nebulous patents all the time that are certainly not
>>> "demonstrated to work". Patent trolls don't make money by creating
>>> patented product, they make money through litigation if they think
>>> their vague patents can be asserted in a congenial legal district.
>>>
>>> /Flibble
>>>
>>
>> And you are not aware that such patents can be declared invalid, and
>> the trolls required to pay the legal fees of the chalenger if said
>> patent is determined to have been fraudulently field.
>>
>> Yes, some trolls do get away with invalid patents because it isn't
>> worth the effort.
>>
>> Note also, "work" doesn't need to be commercially viable, so can be a
>> low standard in some fields.
>>
>> A patent must include a sample implementation of the invention it
>> claims, and claims about what that implementation can do. "Lying"
>> about that ability invalidates the patent.
>
> Filing a patent and ruling a filed patent is invalid in court are two
> different things, dear.
>
> /Flibble
>

On 11/12/22 11:42 AM, Mr Flibble wrote:
> On Sat, 12 Nov 2022 11:09:56 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/12/22 10:52 AM, Mr Flibble wrote:
>>> On Sat, 12 Nov 2022 10:41:58 -0500
>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>
>>>> On 11/12/22 10:16 AM, Mr Flibble wrote:
>>>>> On Sat, 12 Nov 2022 09:58:47 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>
>>>>>> On 11/12/22 9:35 AM, olcott wrote:
>>>>>>> On 11/12/2022 8:31 AM, Mr Flibble wrote:
>>>>>>>> On Sat, 12 Nov 2022 09:15:04 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>
>>>>>>>>> On 11/12/22 12:35 AM, olcott wrote:
>>>>>>>>>> On 11/11/2022 8:31 PM, Sergi o wrote:
>>>>>>>>>>> On 11/11/2022 8:21 PM, olcott wrote:
>>>>>>>>>>>> On 11/11/2022 1:56 PM, Jeff Barnett wrote:
>>>>>>>>>>>>> On 11/11/2022 11:43 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you and I
>>>>>>>>>>>>>>> would have thought given your intelligence you would
>>>>>>>>>>>>>>> also understand that.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I say this because at times he seems to respond to what I
>>>>>>>>>>>>>> say, even if not in a direct reply,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>
>>>>>>>>>>>>> How is that working? Do you really think that repeating
>>>>>>>>>>>>> yourself literally 1000's of times makes good reading?
>>>>>>>>>>>>> Almost anyone who can look deeply enough into the logic
>>>>>>>>>>>>> will notice you engaging in a supposed dialogue with a
>>>>>>>>>>>>> stone wall (actually a stone brain). After your first half
>>>>>>>>>>>>> dozen messages a few years ago, you have added nothing to
>>>>>>>>>>>>> the conversation. Time to move on.
>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It's a trivial truth and few will be fooled. Further, the
>>>>>>>>>>>>> real truth tellers and teachers do not hang out in these
>>>>>>>>>>>>> groups or archives. Too many truth tellers too few
>>>>>>>>>>>>> acolytes shrewd enough to know who has the inside track
>>>>>>>>>>>>> on god's word. Did you know that PO, in his less lucid
>>>>>>>>>>>>> moments, thinks he's a truth teller too? Truth tellers
>>>>>>>>>>>>> only pass the word when they preach to the choir.
>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his explanation
>>>>>>>>>>>>>> into explicit words, his errors become very apparent, I
>>>>>>>>>>>>>> think even to him, so he just refuses.
>>>>>>>>>>>>>
>>>>>>>>>>>>> So what? Rather than save the world from a babbling idiot,
>>>>>>>>>>>>> why not rescue homeless puppies at risk? You would be
>>>>>>>>>>>>> doing a better thing and would be more admired. A
>>>>>>>>>>>>> mathematical social worker is not needed.
>>>>>>>>>>>>>
>>>>>>>>>>>>> I think, instead, you don't know what to do with your time
>>>>>>>>>>>>> and have select this task to fill the gaps. Anyone
>>>>>>>>>>>>> studying the archives will notice that PO is the clear
>>>>>>>>>>>>> victor in all these threads. His head is too thick to be
>>>>>>>>>>>>> bothered by facts or sort-of facts; he's too ignorant and
>>>>>>>>>>>>> proud to be bothered by anyone else's facts or religion;
>>>>>>>>>>>>> and some of your presentations (articles) are not worded
>>>>>>>>>>>>> in the best way or are slightly misleading to someone who
>>>>>>>>>>>>> doesn't already know most of what you meant to say.
>>>>>>>>>>>>> (That's a problem with most of us writing articles
>>>>>>>>>>>>> without a few hours reflection before posting.) You will
>>>>>>>>>>>>> not win this way.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Since I think you seek recognition for your efforts as a
>>>>>>>>>>>>> white knight and it's not working, I suggest you go black
>>>>>>>>>>>>> hat! Beat PO at his own game: Initiate threads five to
>>>>>>>>>>>>> twenty times a week; Have response chains where you
>>>>>>>>>>>>> respond significant numbers of times to your own
>>>>>>>>>>>>> articles; Be outrageous!
>>>>>>>>>>>>>
>>>>>>>>>>>>> This will only work if you devote enough time to take all
>>>>>>>>>>>>> of the PO USENET distinctions away from him. You must,
>>>>>>>>>>>>> every month, win the honors for (1) most threads started,
>>>>>>>>>>>>> (2) most number of responses to threads you have started,
>>>>>>>>>>>>> (3) most posts by an individual, (4) threads with largest
>>>>>>>>>>>>> number of indentations, (5) the highest number of almost
>>>>>>>>>>>>> repetitious posts - slight variations required, (6)
>>>>>>>>>>>>> highest percentage of silly capitalization, and (7) most
>>>>>>>>>>>>> times breaking USENET rules on text postings.
>>>>>>>>>>>>>
>>>>>>>>>>>>> When you follow the above seven point program (and you are
>>>>>>>>>>>>> well on your way in many of the points) you will eclipse
>>>>>>>>>>>>> PO and he will go POOF into a heap of dust. You will have
>>>>>>>>>>>>> won! At last. and history and the titles will be yours.
>>>>>>>>>>>>> You will be known to future USENET generations, for as
>>>>>>>>>>>>> long as the archives are maintained, as a winner.
>>>>>>>>>>>>>
>>>>>>>>>>>>> However, and this is an important however, you will have
>>>>>>>>>>>>> approximately the same impact on the truth as you do now.
>>>>>>>>>>>>> Why not have fun instead?
>>>>>>>>>>>>
>>>>>>>>>>>> I made the basis of my proof much easier to understand so
>>>>>>>>>>>> that anyone that is an expert in the C programming language
>>>>>>>>>>>> would be able to understand a simulating halt decider.
>>>>>>>>>>>>
>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>     H(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> When H(D,D) returns 0 it correctly predicts that D
>>>>>>>>>>>> correctly simulated by H would never reach its own final
>>>>>>>>>>>> state and terminate normally after 1 to ∞ of correct
>>>>>>>>>>>> simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> I predict that no one will be able to find any actual error
>>>>>>>>>>>> with that.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> if it doesn't bust the compiler, run it through a code
>>>>>>>>>>> checker, lots of free ones out there
>>>>>>>>>>>
>>>>>>>>>>> https://www.onlinegdb.com/online_c_compiler
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The last remaining issue is the acceptance of the notion of a
>>>>>>>>>> simulating halt decider.
>>>>>>>>>
>>>>>>>>> Why, It is actually a well know concept, as a PARTIAL solution
>>>>>>>>> of the problem.
>>>>>>>>>
>>>>>>>>> I remember it being shown as why you CAN'T just solve the
>>>>>>>>> problem with one.
>>>>>>>>>
>>>>>>>>> Your ignorance of the history of this topic has doomed you to
>>>>>>>>> repeat all the errors that others have made in the past.
>>>>>>>>
>>>>>>>> A simulating halt decider is Olcott's idea.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>
>>>>>>> Thanks. I was thinking about filing a trademark on it.
>>>>>>>
>>>>>>
>>>>>> Go ahead and waste your money.
>>>>>>
>>>>>> I remember the discussion of trying to determine halting by
>>>>>> simulation back in my school days, so not a new concept. Normally
>>>>>> showing the simple reasons about why it doesn't work.
>>>>>>
>>>>>> Note, this is pre-internet, so your Google searches not bringing
>>>>>> it up is understandable.
>>>>>>
>>>>>> Likely didn't reach "published papers" as it was a well known
>>>>>> dead end so no need to write the paper.
>>>>>
>>>>> So you have no evidence to backup that claim. So no prior art
>>>>> leaving Olcott free to trademark or file a patent.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> He can't file a patent, as he has publicly disclosed the idea too
>>>> long ago. Public disclosure precludes later patent. If he filed a
>>>> preliminary patent BEFORE disclosure, he is given a limited amount
>>>> of time to finalize it, but I think too much time has passed now
>>>> for that to be an option.
>>>>
>>>> There is also the problem tha that you need to demonstrate that it
>>>> works.
>>>
>>> You are obviously unaware of the USPTO which allows patent trolls to
>>> file vague nebulous patents all the time that are certainly not
>>> "demonstrated to work". Patent trolls don't make money by creating
>>> patented product, they make money through litigation if they think
>>> their vague patents can be asserted in a congenial legal district.
>>>
>>> /Flibble
>>>
>>
>> And you are not aware that such patents can be declared invalid, and
>> the trolls required to pay the legal fees of the chalenger if said
>> patent is determined to have been fraudulently field.
>>
>> Yes, some trolls do get away with invalid patents because it isn't
>> worth the effort.
>>
>> Note also, "work" doesn't need to be commercially viable, so can be a
>> low standard in some fields.
>>
>> A patent must include a sample implementation of the invention it
>> claims, and claims about what that implementation can do. "Lying"
>> about that ability invalidates the patent.
>
> Filing a patent and ruling a filed patent is invalid in court are two
> different things, dear.
>
> /Flibble
>

On 11/12/22 12:00 PM, olcott wrote:
> On 11/12/2022 10:26 AM, Richard Damon wrote:
>> On 11/12/22 10:50 AM, olcott wrote:
>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>
>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>>> and I would have thought given your intelligence you
>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct simulation, so any
>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>
>>>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>>>> wrong is the mapping of the need to abort the simulation to a
>>>>>>>>>>>> halt decision of non-halting; it needs to instead be mapped to
>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>
>>>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>>>> directly express a reference.
>>>>>>>>>>
>>>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>>>> all the way down so is the same category error manifesting in a
>>>>>>>>>> different way.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>>>> actually a decider.
>>>>>>>>>
>>>>>>>>> If we assume a prospective decider exists, then the "Impossible"
>>>>>>>>> program is simple to make from it, and is given one copy of the
>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>
>>>>>>>>> When run it makes a second copy of its description, and then
>>>>>>>>> calls the decider.
>>>>>>>>>
>>>>>>>>> After that, it is the deciders job to make the decision in finite
>>>>>>>>> time, by whatever method it wants. If it gets stuck in your
>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>
>>>>>>>>> The proof shows that what ever answer the decider does give (if
>>>>>>>>> it gives one) will be wrong, and thus the decider doesn't meet
>>>>>>>>> the requirements.
>>>>>>>>>
>>>>>>>>> No "Self Reference" in sight there only a program being given a
>>>>>>>>> copy of something that just happens to be its own description.
>>>>>>>>>
>>>>>>>>> The only place we get any form of "Reference", is when we try to
>>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge. There the
>>>>>>>>> effect of the Self-Reference just lets us see that the task turns
>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>
>>>>>>>> You are fractally wrong on all fronts: in the traditional halting
>>>>>>>> problem proofs based on [Strachey 1965] the program is impossible
>>>>>>>> not due to self reference or infinite copies but because the input
>>>>>>>> tries to do the opposite of what the decider decides; the category
>>>>>>>> error that I have identified is different: it is an error of self
>>>>>>>> reference and/or infinite copies; it is an error related to the
>>>>>>>> fact that the input references a decider rather than being related
>>>>>>>> to what the input does with the decision result of a decider.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>> Strachey's program. The decider is SUPPOSED to be able to handle
>>>>>>> ANY input and answer in finite time, If an input causes it to make
>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>> requirements.
>>>>>>>
>>>>>>> Turing Machine can ALWAYS be legally built based on another Turing
>>>>>>> Machine as a base. The only reason it wouldn't be allowed is if H
>>>>>>> isn't actually a Turing Machine, so it CAN'T be a category error
>>>>>>> if H is actualy a Turing Machine.
>>>>>>>
>>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>>> admitting that your H can't actually be a Turing Machine, but must
>>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>>> requirement to be the needed decider.
>>>>>>
>>>>>> In which case we get infinite turning machines all the way down: yet
>>>>>> another manifestation of the category error I have identified.
>>>>>>
>>>>>> /Flibble
>>>>>
>>>>> Where are infinite machines? There is ONE machine being run, either H
>>>>> or D, and it SIMULATING others, and if we get an infinite sequence of
>>>>> simulations we have just shown that H was defective because it failed
>>>>> to answer in finite time.
>>>>>
>>>>> This isn't a category error, but a design error in H.
>>>>>
>>>>> Note, when we start H, there is exactly two machines present in
>>>>> representation on the tape, and two is much smaller than infinity.
>>>>
>>>> Nope, if,
>>>>
>>>> a) H is a copy, and
>>>> b) H is a Turing Machine, and
>>>> c) D is an input into H, and
>>>> d) D references H, and
>>>> e) H references D,
>>>>
>>>> then (d) and (e) repeat ad infinitum so we get infinite Turing Machines
>>>> all the way down: a manifestation of the category error I have
>>>> identified.
>>>>
>>>> /Flibble
>>>>
>>>
>>> void E(void (*x)())
>>> {
>>>    H(x, x);
>>> }
>>>
>>> The point is
>>> that D correctly simulated by H would never reach its own last
>>> instruction and terminate normally after 1 to ∞ steps of correct
>>> simulation.
>>>
>>> When H returns 0 to main() it is indicating
>>>
>>> that D correctly simulated by H would never reach its own last
>>> instruction and terminate normally after 1 to ∞ steps of correct
>>> simulation.
>>>
>>
>> Except D is NOT correctly simulated by H, so that is a incorrect
>> statement. When it is correctly simulated by something other than H,
>> it will come to a final state, showing your statement is wrong.
> In order for the simulation to actually be incorrect the execution trace
> of the simulated E must diverge from the behavior that the line-by-line
> x86 source-code of E specifies.

On 11/12/2022 11:59 AM, Richard Damon wrote:
> On 11/12/22 12:00 PM, olcott wrote:
>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>> On 11/12/22 10:50 AM, olcott wrote:
>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>
>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>>>> and I would have thought given your intelligence you
>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the Truth.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the infinite
>>>>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct simulation, so any
>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>>>>> wrong is the mapping of the need to abort the simulation to a
>>>>>>>>>>>>> halt decision of non-halting; it needs to instead be mapped to
>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>
>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>
>>>>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>
>>>>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>>>>> all the way down so is the same category error manifesting in a
>>>>>>>>>>> different way.
>>>>>>>>>>>
>>>>>>>>>>> /Flibble
>>>>>>>>>>
>>>>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>>>>> actually a decider.
>>>>>>>>>>
>>>>>>>>>> If we assume a prospective decider exists, then the "Impossible"
>>>>>>>>>> program is simple to make from it, and is given one copy of the
>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>
>>>>>>>>>> When run it makes a second copy of its description, and then
>>>>>>>>>> calls the decider.
>>>>>>>>>>
>>>>>>>>>> After that, it is the deciders job to make the decision in finite
>>>>>>>>>> time, by whatever method it wants. If it gets stuck in your
>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>
>>>>>>>>>> The proof shows that what ever answer the decider does give (if
>>>>>>>>>> it gives one) will be wrong, and thus the decider doesn't meet
>>>>>>>>>> the requirements.
>>>>>>>>>>
>>>>>>>>>> No "Self Reference" in sight there only a program being given a
>>>>>>>>>> copy of something that just happens to be its own description.
>>>>>>>>>>
>>>>>>>>>> The only place we get any form of "Reference", is when we try to
>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge. There the
>>>>>>>>>> effect of the Self-Reference just lets us see that the task turns
>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>
>>>>>>>>> You are fractally wrong on all fronts: in the traditional halting
>>>>>>>>> problem proofs based on [Strachey 1965] the program is impossible
>>>>>>>>> not due to self reference or infinite copies but because the input
>>>>>>>>> tries to do the opposite of what the decider decides; the category
>>>>>>>>> error that I have identified is different: it is an error of self
>>>>>>>>> reference and/or infinite copies; it is an error related to the
>>>>>>>>> fact that the input references a decider rather than being related
>>>>>>>>> to what the input does with the decision result of a decider.
>>>>>>>>>
>>>>>>>>> /Flibble
>>>>>>>>
>>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>>> Strachey's program. The decider is SUPPOSED to be able to handle
>>>>>>>> ANY input and answer in finite time, If an input causes it to make
>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>> requirements.
>>>>>>>>
>>>>>>>> Turing Machine can ALWAYS be legally built based on another Turing
>>>>>>>> Machine as a base. The only reason it wouldn't be allowed is if H
>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a category error
>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>
>>>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>>>> admitting that your H can't actually be a Turing Machine, but must
>>>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>>>> requirement to be the needed decider.
>>>>>>>
>>>>>>> In which case we get infinite turning machines all the way down: yet
>>>>>>> another manifestation of the category error I have identified.
>>>>>>>
>>>>>>> /Flibble
>>>>>>
>>>>>> Where are infinite machines? There is ONE machine being run, either H
>>>>>> or D, and it SIMULATING others, and if we get an infinite sequence of
>>>>>> simulations we have just shown that H was defective because it failed
>>>>>> to answer in finite time.
>>>>>>
>>>>>> This isn't a category error, but a design error in H.
>>>>>>
>>>>>> Note, when we start H, there is exactly two machines present in
>>>>>> representation on the tape, and two is much smaller than infinity.
>>>>>
>>>>> Nope, if,
>>>>>
>>>>> a) H is a copy, and
>>>>> b) H is a Turing Machine, and
>>>>> c) D is an input into H, and
>>>>> d) D references H, and
>>>>> e) H references D,
>>>>>
>>>>> then (d) and (e) repeat ad infinitum so we get infinite Turing
>>>>> Machines
>>>>> all the way down: a manifestation of the category error I have
>>>>> identified.
>>>>>
>>>>> /Flibble
>>>>>
>>>>
>>>> void E(void (*x)())
>>>> {
>>>>    H(x, x);
>>>> }
>>>>
>>>> The point is
>>>> that D correctly simulated by H would never reach its own last
>>>> instruction and terminate normally after 1 to ∞ steps of correct
>>>> simulation.
>>>>
>>>> When H returns 0 to main() it is indicating
>>>>
>>>> that D correctly simulated by H would never reach its own last
>>>> instruction and terminate normally after 1 to ∞ steps of correct
>>>> simulation.
>>>>
>>>
>>> Except D is NOT correctly simulated by H, so that is a incorrect
>>> statement. When it is correctly simulated by something other than H,
>>> it will come to a final state, showing your statement is wrong.
>> In order for the simulation to actually be incorrect the execution
>> trace of the simulated E must diverge from the behavior that the
>> line-by-line x86 source-code of E specifies.
>
> Right, and since you simulation does NOT continue past the call to H, it
> is "incorrect" in the sense that the actual code does continue past that
> point, so it does not actually match the behavior of that machine.
>
>>
>> The first seven lines of the execution trace of the simulated E
>> exactly match the behavior specified by the first seven lines of the
>> x86 source code of E. This conclusively proves beyond all possible
>> doubt that these first seven lines have been simulated correctly.
>
> Right, so H has correctly done a PARTIAL simulation of its input, which
> does NOT prove the input is non-halting.
>
>>
>> *H correctly determines that E never halts*
>>
>> void E(void (*x)())
>> {
>>    H(x, x);
>> }
>>
>>
>> int main()
>> {
>>    Output("Input_Halts = ", H(E, E));
>> }
>>
>> _E()
>> [000019d2] 55             push ebp
>> [000019d3] 8bec           mov ebp,esp
>> [000019d5] 8b4508         mov eax,[ebp+08]
>> [000019d8] 50             push eax
>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>> [000019dc] 51             push ecx
>> [000019dd] e8b0f9ffff     call 00001392
>> [000019e2] 83c408         add esp,+08
>> [000019e5] 5d             pop ebp
>> [000019e6] c3             ret
>> Size in bytes:(0021) [000019e6]
>>
>> _main()
>> [000019f2] 55             push ebp
>> [000019f3] 8bec           mov ebp,esp
>> [000019f5] 68d2190000     push 000019d2
>> [000019fa] 68d2190000     push 000019d2
>> [000019ff] e88ef9ffff     call 00001392
>> [00001a04] 83c408         add esp,+08
>> [00001a07] 50             push eax
>> [00001a08] 6893060000     push 00000693
>> [00001a0d] e8a0ecffff     call 000006b2
>> [00001a12] 83c408         add esp,+08
>> [00001a15] 33c0           xor eax,eax
>> [00001a17] 5d             pop ebp
>> [00001a18] c3             ret
>> Size in bytes:(0039) [00001a18]
>>
>>   machine   stack     stack     machine    assembly
>>   address   address   data      code       language
>>   ========  ========  ========  =========  =============
>> [000019f2][00102a7c][00000000] 55         push ebp
>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H
>>
>> H: Begin Simulation   Execution Trace Stored at:112b28
>> Address_of_H:1392
>> [000019d2][00112b14][00112b18] 55         push ebp
>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>> [000019d8][00112b10][000019d2] 50         push eax         // push E
>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>> [000019dc][00112b0c][000019d2] 51         push ecx         // push E
>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    // call H
>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>
>> H correctly reports that E correctly simulated by H cannot possibly
>> reach its own final state at machine address [000019e6] and terminate
>> normally in 1 to ∞ steps of correct simulation.
>>
>>
>
> So you are just admitting you don't understand the Halting Criteria.
>
> The fact that H stops its simulation before it gets to the end does NOT
> prove that the machine being simulated, or a correct and complete
> simultion of the input would be non-halting.
We must handle only one point at a time because you are easily
overwhelmed. You usually cannot even handle one point at a time until
this point is repeated 20 or more times.

On Sat, 12 Nov 2022 12:59:18 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/12/22 12:00 PM, olcott wrote:
> > On 11/12/2022 10:26 AM, Richard Damon wrote:
> >> On 11/12/22 10:50 AM, olcott wrote:
> >>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
> >>>> On Sat, 12 Nov 2022 09:52:12 -0500
> >>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>
> >>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
> >>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
> >>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
> >>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
> >>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
> >>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
> >>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
> >>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
> >>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked
> >>>>>>>>>>>>>>>>>>>> you and I would have thought given your
> >>>>>>>>>>>>>>>>>>>> intelligence you would also understand that.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just
> >>>>>>>>>>>>>>>>>>> mostly ignores me.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
> >>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he
> >>>>>>>>>>>>>>>>>>> has blocked me, he will still see me.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
> >>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to
> >>>>>>>>>>>>>>>>>>> point out his errors.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
> >>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the
> >>>>>>>>>>>>>>>>>>> Truth.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that
> >>>>>>>>>>>>>>>>>>> he doesn't actually know what he is talking
> >>>>>>>>>>>>>>>>>>> about, and reveals his ignorance. If he tries to
> >>>>>>>>>>>>>>>>>>> put his explanation into explicit words, his
> >>>>>>>>>>>>>>>>>>> errors become very apparent, I think even to him,
> >>>>>>>>>>>>>>>>>>> so he just refuses.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
> >>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet
> >>>>>>>>>>>>>>>>>> naive readers are not in my target audience.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a
> >>>>>>>>>>>>>>>>> Halting Decider.
> >>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal
> >>>>>>>>>>>>>>>> Turing machine (UTM) knows that the behavior of D
> >>>>>>>>>>>>>>>> correctly simulated by H provides H with a correct
> >>>>>>>>>>>>>>>> basis for its halt status decision.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> void E(void (*x)())
> >>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>         H(x, x);
> >>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
> >>>>>>>>>>>>>> infinite execution of E is correct to report
> >>>>>>>>>>>>>> non-halting. No shell game can correctly deny this.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT
> >>>>>>>>>>>>> because the CORRECT simulation, as will the diret
> >>>>>>>>>>>>> exectuion, will halt. Note, such an H doesn't do a
> >>>>>>>>>>>>> correct simulation, so any arguement based on it doing
> >>>>>>>>>>>>> so it just WRONG.
> >>>>>>>>>>>>
> >>>>>>>>>>>> The need to abort the simulation is due to the self
> >>>>>>>>>>>> reference category error present in the proof; what
> >>>>>>>>>>>> Olcott is getting wrong is the mapping of the need to
> >>>>>>>>>>>> abort the simulation to a halt decision of non-halting;
> >>>>>>>>>>>> it needs to instead be mapped to INVALID INPUT.
> >>>>>>>>>>>>
> >>>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>> Nope, no self reference.
> >>>>>>>>>>>
> >>>>>>>>>>> E just has a copy of the H that claim to be deciding it,
> >>>>>>>>>>> not a "reference" to it. Turing Machines do not have the
> >>>>>>>>>>> power to directly express a reference.
> >>>>>>>>>>
> >>>>>>>>>> Nope, if it isn't a self reference then it is infinite
> >>>>>>>>>> copies all the way down so is the same category error
> >>>>>>>>>> manifesting in a different way.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>> Only if the "decider" makes that happen, in which case it
> >>>>>>>>> isn't actually a decider.
> >>>>>>>>>
> >>>>>>>>> If we assume a prospective decider exists, then the
> >>>>>>>>> "Impossible" program is simple to make from it, and is
> >>>>>>>>> given one copy of the description of itself, which is also
> >>>>>>>>> simple to make.
> >>>>>>>>>
> >>>>>>>>> When run it makes a second copy of its description, and then
> >>>>>>>>> calls the decider.
> >>>>>>>>>
> >>>>>>>>> After that, it is the deciders job to make the decision in
> >>>>>>>>> finite time, by whatever method it wants. If it gets stuck
> >>>>>>>>> in your infinite loop, the decider is just wrong.
> >>>>>>>>>
> >>>>>>>>> The proof shows that what ever answer the decider does give
> >>>>>>>>> (if it gives one) will be wrong, and thus the decider
> >>>>>>>>> doesn't meet the requirements.
> >>>>>>>>>
> >>>>>>>>> No "Self Reference" in sight there only a program being
> >>>>>>>>> given a copy of something that just happens to be its own
> >>>>>>>>> description.
> >>>>>>>>>
> >>>>>>>>> The only place we get any form of "Reference", is when we
> >>>>>>>>> try to ANALYSE or DESIGN the H to try to meet the
> >>>>>>>>> challenge. There the effect of the Self-Reference just lets
> >>>>>>>>> us see that the task turns out be be impossible, so no such
> >>>>>>>>> program exists.
> >>>>>>>>
> >>>>>>>> You are fractally wrong on all fronts: in the traditional
> >>>>>>>> halting problem proofs based on [Strachey 1965] the program
> >>>>>>>> is impossible not due to self reference or infinite copies
> >>>>>>>> but because the input tries to do the opposite of what the
> >>>>>>>> decider decides; the category error that I have identified
> >>>>>>>> is different: it is an error of self reference and/or
> >>>>>>>> infinite copies; it is an error related to the fact that the
> >>>>>>>> input references a decider rather than being related to what
> >>>>>>>> the input does with the decision result of a decider.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>
> >>>>>>> But the infinite copies is a error in the Decider, not in
> >>>>>>> Strachey's program. The decider is SUPPOSED to be able to
> >>>>>>> handle ANY input and answer in finite time, If an input
> >>>>>>> causes it to make infinite copies, then the decided just
> >>>>>>> doesn't meet its requirements.
> >>>>>>>
> >>>>>>> Turing Machine can ALWAYS be legally built based on another
> >>>>>>> Turing Machine as a base. The only reason it wouldn't be
> >>>>>>> allowed is if H isn't actually a Turing Machine, so it CAN'T
> >>>>>>> be a category error if H is actualy a Turing Machine.
> >>>>>>>
> >>>>>>> All your declaration of a "Category Error" here is doing is
> >>>>>>> admitting that your H can't actually be a Turing Machine, but
> >>>>>>> must be of a HIGHER order logic system, which means H fails
> >>>>>>> the requirement to be the needed decider.
> >>>>>>
> >>>>>> In which case we get infinite turning machines all the way
> >>>>>> down: yet another manifestation of the category error I have
> >>>>>> identified.
> >>>>>>
> >>>>>> /Flibble
> >>>>>
> >>>>> Where are infinite machines? There is ONE machine being run,
> >>>>> either H or D, and it SIMULATING others, and if we get an
> >>>>> infinite sequence of simulations we have just shown that H was
> >>>>> defective because it failed to answer in finite time.
> >>>>>
> >>>>> This isn't a category error, but a design error in H.
> >>>>>
> >>>>> Note, when we start H, there is exactly two machines present in
> >>>>> representation on the tape, and two is much smaller than
> >>>>> infinity.
> >>>>
> >>>> Nope, if,
> >>>>
> >>>> a) H is a copy, and
> >>>> b) H is a Turing Machine, and
> >>>> c) D is an input into H, and
> >>>> d) D references H, and
> >>>> e) H references D,
> >>>>
> >>>> then (d) and (e) repeat ad infinitum so we get infinite Turing
> >>>> Machines all the way down: a manifestation of the category error
> >>>> I have identified.
> >>>>
> >>>> /Flibble
> >>>>
> >>>
> >>> void E(void (*x)())
> >>> {
> >>>    H(x, x);
> >>> }
> >>>
> >>> The point is
> >>> that D correctly simulated by H would never reach its own last
> >>> instruction and terminate normally after 1 to ∞ steps of correct
> >>> simulation.
> >>>
> >>> When H returns 0 to main() it is indicating
> >>>
> >>> that D correctly simulated by H would never reach its own last
> >>> instruction and terminate normally after 1 to ∞ steps of correct
> >>> simulation.
> >>>
> >>
> >> Except D is NOT correctly simulated by H, so that is a incorrect
> >> statement. When it is correctly simulated by something other than
> >> H, it will come to a final state, showing your statement is wrong.
> >>
> > In order for the simulation to actually be incorrect the execution
> > trace of the simulated E must diverge from the behavior that the
> > line-by-line x86 source-code of E specifies.
>
> Right, and since you simulation does NOT continue past the call to H,
> it is "incorrect" in the sense that the actual code does continue
> past that point, so it does not actually match the behavior of that
> machine.
>
> >
> > The first seven lines of the execution trace of the simulated E
> > exactly match the behavior specified by the first seven lines of
> > the x86 source code of E. This conclusively proves beyond all
> > possible doubt that these first seven lines have been simulated
> > correctly.
>
> Right, so H has correctly done a PARTIAL simulation of its input,
> which does NOT prove the input is non-halting.
>
> >
> > *H correctly determines that E never halts*
> >
> > void E(void (*x)())
> > {
> >   H(x, x);
> > }
> >
> >
> > int main()
> > {
> >   Output("Input_Halts = ", H(E, E));
> > }
> >
> > _E()
> > [000019d2] 55             push ebp
> > [000019d3] 8bec           mov ebp,esp
> > [000019d5] 8b4508         mov eax,[ebp+08]
> > [000019d8] 50             push eax
> > [000019d9] 8b4d08         mov ecx,[ebp+08]
> > [000019dc] 51             push ecx
> > [000019dd] e8b0f9ffff     call 00001392
> > [000019e2] 83c408         add esp,+08
> > [000019e5] 5d             pop ebp
> > [000019e6] c3             ret
> > Size in bytes:(0021) [000019e6]
> >
> > _main()
> > [000019f2] 55             push ebp
> > [000019f3] 8bec           mov ebp,esp
> > [000019f5] 68d2190000     push 000019d2
> > [000019fa] 68d2190000     push 000019d2
> > [000019ff] e88ef9ffff     call 00001392
> > [00001a04] 83c408         add esp,+08
> > [00001a07] 50             push eax
> > [00001a08] 6893060000     push 00000693
> > [00001a0d] e8a0ecffff     call 000006b2
> > [00001a12] 83c408         add esp,+08
> > [00001a15] 33c0           xor eax,eax
> > [00001a17] 5d             pop ebp
> > [00001a18] c3             ret
> > Size in bytes:(0039) [00001a18]
> >
> >  machine   stack     stack     machine    assembly
> >  address   address   data      code       language
> >  ========  ========  ========  =========  ============> > [000019f2][00102a7c][00000000] 55         push ebp
> > [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
> > [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
> > [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
> > [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H
> >
> > H: Begin Simulation   Execution Trace Stored at:112b28
> > Address_of_H:1392
> > [000019d2][00112b14][00112b18] 55         push ebp
> > [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
> > [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
> > [000019d8][00112b10][000019d2] 50         push eax         // push E
> > [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
> > [000019dc][00112b0c][000019d2] 51         push ecx         // push E
> > [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    // call H
> > H: Infinitely Recursive Simulation Detected Simulation Stopped
> >
> > H correctly reports that E correctly simulated by H cannot possibly
> > reach its own final state at machine address [000019e6] and
> > terminate normally in 1 to ∞ steps of correct simulation.
> >
> >
>
> So you are just admitting you don't understand the Halting Criteria.
>
> The fact that H stops its simulation before it gets to the end does
> NOT prove that the machine being simulated, or a correct and complete
> simultion of the input would be non-halting.
>
> Or, do you claim that you have correctly climbed Mount Everest since
> ever step of you climb of it were correct?
>
> You are just proving you lack of understanding of the meaning of a
> correct simulation.

On 11/12/22 1:16 PM, olcott wrote:
> On 11/12/2022 11:59 AM, Richard Damon wrote:
>> On 11/12/22 12:00 PM, olcott wrote:
>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked you
>>>>>>>>>>>>>>>>>>>>>> and I would have thought given your intelligence you
>>>>>>>>>>>>>>>>>>>>>> would also understand that.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just mostly
>>>>>>>>>>>>>>>>>>>>> ignores me.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he has
>>>>>>>>>>>>>>>>>>>>> blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to point
>>>>>>>>>>>>>>>>>>>>> out his errors.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the
>>>>>>>>>>>>>>>>>>>>> Truth.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that he
>>>>>>>>>>>>>>>>>>>>> doesn't actually know what he is talking about, and
>>>>>>>>>>>>>>>>>>>>> reveals his ignorance. If he tries to put his
>>>>>>>>>>>>>>>>>>>>> explanation into explicit words, his errors become
>>>>>>>>>>>>>>>>>>>>> very apparent, I think even to him, so he just
>>>>>>>>>>>>>>>>>>>>> refuses.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet naive
>>>>>>>>>>>>>>>>>>>> readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a Halting
>>>>>>>>>>>>>>>>>>> Decider.
>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal Turing
>>>>>>>>>>>>>>>>>> machine (UTM) knows that the behavior of D correctly
>>>>>>>>>>>>>>>>>> simulated by H provides H with a correct basis for its
>>>>>>>>>>>>>>>>>> halt status decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
>>>>>>>>>>>>>>>> infinite
>>>>>>>>>>>>>>>> execution of E is correct to report non-halting. No shell
>>>>>>>>>>>>>>>> game can correctly deny this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT because
>>>>>>>>>>>>>>> the CORRECT simulation, as will the diret exectuion, will
>>>>>>>>>>>>>>> halt. Note, such an H doesn't do a correct simulation, so
>>>>>>>>>>>>>>> any
>>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The need to abort the simulation is due to the self reference
>>>>>>>>>>>>>> category error present in the proof; what Olcott is getting
>>>>>>>>>>>>>> wrong is the mapping of the need to abort the simulation to a
>>>>>>>>>>>>>> halt decision of non-halting; it needs to instead be
>>>>>>>>>>>>>> mapped to
>>>>>>>>>>>>>> INVALID INPUT.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>
>>>>>>>>>>>>> E just has a copy of the H that claim to be deciding it, not a
>>>>>>>>>>>>> "reference" to it. Turing Machines do not have the power to
>>>>>>>>>>>>> directly express a reference.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, if it isn't a self reference then it is infinite copies
>>>>>>>>>>>> all the way down so is the same category error manifesting in a
>>>>>>>>>>>> different way.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> Only if the "decider" makes that happen, in which case it isn't
>>>>>>>>>>> actually a decider.
>>>>>>>>>>>
>>>>>>>>>>> If we assume a prospective decider exists, then the "Impossible"
>>>>>>>>>>> program is simple to make from it, and is given one copy of the
>>>>>>>>>>> description of itself, which is also simple to make.
>>>>>>>>>>>
>>>>>>>>>>> When run it makes a second copy of its description, and then
>>>>>>>>>>> calls the decider.
>>>>>>>>>>>
>>>>>>>>>>> After that, it is the deciders job to make the decision in
>>>>>>>>>>> finite
>>>>>>>>>>> time, by whatever method it wants. If it gets stuck in your
>>>>>>>>>>> infinite loop, the decider is just wrong.
>>>>>>>>>>>
>>>>>>>>>>> The proof shows that what ever answer the decider does give (if
>>>>>>>>>>> it gives one) will be wrong, and thus the decider doesn't meet
>>>>>>>>>>> the requirements.
>>>>>>>>>>>
>>>>>>>>>>> No "Self Reference" in sight there only a program being given a
>>>>>>>>>>> copy of something that just happens to be its own description.
>>>>>>>>>>>
>>>>>>>>>>> The only place we get any form of "Reference", is when we try to
>>>>>>>>>>> ANALYSE or DESIGN the H to try to meet the challenge. There the
>>>>>>>>>>> effect of the Self-Reference just lets us see that the task
>>>>>>>>>>> turns
>>>>>>>>>>> out be be impossible, so no such program exists.
>>>>>>>>>>
>>>>>>>>>> You are fractally wrong on all fronts: in the traditional halting
>>>>>>>>>> problem proofs based on [Strachey 1965] the program is impossible
>>>>>>>>>> not due to self reference or infinite copies but because the
>>>>>>>>>> input
>>>>>>>>>> tries to do the opposite of what the decider decides; the
>>>>>>>>>> category
>>>>>>>>>> error that I have identified is different: it is an error of self
>>>>>>>>>> reference and/or infinite copies; it is an error related to the
>>>>>>>>>> fact that the input references a decider rather than being
>>>>>>>>>> related
>>>>>>>>>> to what the input does with the decision result of a decider.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>>>> Strachey's program. The decider is SUPPOSED to be able to handle
>>>>>>>>> ANY input and answer in finite time, If an input causes it to make
>>>>>>>>> infinite copies, then the decided just doesn't meet its
>>>>>>>>> requirements.
>>>>>>>>>
>>>>>>>>> Turing Machine can ALWAYS be legally built based on another Turing
>>>>>>>>> Machine as a base. The only reason it wouldn't be allowed is if H
>>>>>>>>> isn't actually a Turing Machine, so it CAN'T be a category error
>>>>>>>>> if H is actualy a Turing Machine.
>>>>>>>>>
>>>>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>>>>> admitting that your H can't actually be a Turing Machine, but must
>>>>>>>>> be of a HIGHER order logic system, which means H fails the
>>>>>>>>> requirement to be the needed decider.
>>>>>>>>
>>>>>>>> In which case we get infinite turning machines all the way down:
>>>>>>>> yet
>>>>>>>> another manifestation of the category error I have identified.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> Where are infinite machines? There is ONE machine being run,
>>>>>>> either H
>>>>>>> or D, and it SIMULATING others, and if we get an infinite
>>>>>>> sequence of
>>>>>>> simulations we have just shown that H was defective because it
>>>>>>> failed
>>>>>>> to answer in finite time.
>>>>>>>
>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>
>>>>>>> Note, when we start H, there is exactly two machines present in
>>>>>>> representation on the tape, and two is much smaller than infinity.
>>>>>>
>>>>>> Nope, if,
>>>>>>
>>>>>> a) H is a copy, and
>>>>>> b) H is a Turing Machine, and
>>>>>> c) D is an input into H, and
>>>>>> d) D references H, and
>>>>>> e) H references D,
>>>>>>
>>>>>> then (d) and (e) repeat ad infinitum so we get infinite Turing
>>>>>> Machines
>>>>>> all the way down: a manifestation of the category error I have
>>>>>> identified.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> void E(void (*x)())
>>>>> {
>>>>>    H(x, x);
>>>>> }
>>>>>
>>>>> The point is
>>>>> that D correctly simulated by H would never reach its own last
>>>>> instruction and terminate normally after 1 to ∞ steps of correct
>>>>> simulation.
>>>>>
>>>>> When H returns 0 to main() it is indicating
>>>>>
>>>>> that D correctly simulated by H would never reach its own last
>>>>> instruction and terminate normally after 1 to ∞ steps of correct
>>>>> simulation.
>>>>>
>>>>
>>>> Except D is NOT correctly simulated by H, so that is a incorrect
>>>> statement. When it is correctly simulated by something other than H,
>>>> it will come to a final state, showing your statement is wrong.
>>> In order for the simulation to actually be incorrect the execution
>>> trace of the simulated E must diverge from the behavior that the
>>> line-by-line x86 source-code of E specifies.
>>
>> Right, and since you simulation does NOT continue past the call to H,
>> it is "incorrect" in the sense that the actual code does continue past
>> that point, so it does not actually match the behavior of that machine.
>>
>>>
>>> The first seven lines of the execution trace of the simulated E
>>> exactly match the behavior specified by the first seven lines of the
>>> x86 source code of E. This conclusively proves beyond all possible
>>> doubt that these first seven lines have been simulated correctly.
>>
>> Right, so H has correctly done a PARTIAL simulation of its input,
>> which does NOT prove the input is non-halting.
>>
>>>
>>> *H correctly determines that E never halts*
>>>
>>> void E(void (*x)())
>>> {
>>>    H(x, x);
>>> }
>>>
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", H(E, E));
>>> }
>>>
>>> _E()
>>> [000019d2] 55             push ebp
>>> [000019d3] 8bec           mov ebp,esp
>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>> [000019d8] 50             push eax
>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>> [000019dc] 51             push ecx
>>> [000019dd] e8b0f9ffff     call 00001392
>>> [000019e2] 83c408         add esp,+08
>>> [000019e5] 5d             pop ebp
>>> [000019e6] c3             ret
>>> Size in bytes:(0021) [000019e6]
>>>
>>> _main()
>>> [000019f2] 55             push ebp
>>> [000019f3] 8bec           mov ebp,esp
>>> [000019f5] 68d2190000     push 000019d2
>>> [000019fa] 68d2190000     push 000019d2
>>> [000019ff] e88ef9ffff     call 00001392
>>> [00001a04] 83c408         add esp,+08
>>> [00001a07] 50             push eax
>>> [00001a08] 6893060000     push 00000693
>>> [00001a0d] e8a0ecffff     call 000006b2
>>> [00001a12] 83c408         add esp,+08
>>> [00001a15] 33c0           xor eax,eax
>>> [00001a17] 5d             pop ebp
>>> [00001a18] c3             ret
>>> Size in bytes:(0039) [00001a18]
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [000019f2][00102a7c][00000000] 55         push ebp
>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H
>>>
>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>> Address_of_H:1392
>>> [000019d2][00112b14][00112b18] 55         push ebp
>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>> [000019d8][00112b10][000019d2] 50         push eax         // push E
>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>> [000019dc][00112b0c][000019d2] 51         push ecx         // push E
>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    // call H
>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> H correctly reports that E correctly simulated by H cannot possibly
>>> reach its own final state at machine address [000019e6] and terminate
>>> normally in 1 to ∞ steps of correct simulation.
>>>
>>>
>>
>> So you are just admitting you don't understand the Halting Criteria.
>>
>> The fact that H stops its simulation before it gets to the end does
>> NOT prove that the machine being simulated, or a correct and complete
>> simultion of the input would be non-halting.
> We must handle only one point at a time because you are easily
> overwhelmed. You usually cannot even handle one point at a time until
> this point is repeated 20 or more times.
>
> The fact that the line-by-line execution trace of the first seven
> instructions E simulated by H exactly match the behavior specified by
> the first seven instructions of the x86 source-code of E conclusively
> proves that these first seven instructions are simulated correctly.
>

On 11/12/22 1:19 PM, Mr Flibble wrote:
> On Sat, 12 Nov 2022 12:59:18 -0500
> Richard Damon <Richard@Damon-Family.org> wrote:
>
>> On 11/12/22 12:00 PM, olcott wrote:
>>> On 11/12/2022 10:26 AM, Richard Damon wrote:
>>>> On 11/12/22 10:50 AM, olcott wrote:
>>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
>>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>
>>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
>>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
>>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
>>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
>>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
>>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
>>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
>>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked
>>>>>>>>>>>>>>>>>>>>>> you and I would have thought given your
>>>>>>>>>>>>>>>>>>>>>> intelligence you would also understand that.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just
>>>>>>>>>>>>>>>>>>>>> mostly ignores me.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond to
>>>>>>>>>>>>>>>>>>>>> what I say, even if not in a direct reply,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he
>>>>>>>>>>>>>>>>>>>>> has blocked me, he will still see me.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into the
>>>>>>>>>>>>>>>>>>>>> archives, I want enough evidence to be around to
>>>>>>>>>>>>>>>>>>>>> point out his errors.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know and
>>>>>>>>>>>>>>>>>>>>> provide reasoning behind the claims, showing the
>>>>>>>>>>>>>>>>>>>>> Truth.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show that
>>>>>>>>>>>>>>>>>>>>> he doesn't actually know what he is talking
>>>>>>>>>>>>>>>>>>>>> about, and reveals his ignorance. If he tries to
>>>>>>>>>>>>>>>>>>>>> put his explanation into explicit words, his
>>>>>>>>>>>>>>>>>>>>> errors become very apparent, I think even to him,
>>>>>>>>>>>>>>>>>>>>> so he just refuses.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You always use the strawman deception as your only
>>>>>>>>>>>>>>>>>>>> basis. Naive readers will never notice this, yet
>>>>>>>>>>>>>>>>>>>> naive readers are not in my target audience.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a
>>>>>>>>>>>>>>>>>>> Halting Decider.
>>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal
>>>>>>>>>>>>>>>>>> Turing machine (UTM) knows that the behavior of D
>>>>>>>>>>>>>>>>>> correctly simulated by H provides H with a correct
>>>>>>>>>>>>>>>>>> basis for its halt status decision.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> void E(void (*x)())
>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>         H(x, x);
>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
>>>>>>>>>>>>>>>> infinite execution of E is correct to report
>>>>>>>>>>>>>>>> non-halting. No shell game can correctly deny this.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT
>>>>>>>>>>>>>>> because the CORRECT simulation, as will the diret
>>>>>>>>>>>>>>> exectuion, will halt. Note, such an H doesn't do a
>>>>>>>>>>>>>>> correct simulation, so any arguement based on it doing
>>>>>>>>>>>>>>> so it just WRONG.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The need to abort the simulation is due to the self
>>>>>>>>>>>>>> reference category error present in the proof; what
>>>>>>>>>>>>>> Olcott is getting wrong is the mapping of the need to
>>>>>>>>>>>>>> abort the simulation to a halt decision of non-halting;
>>>>>>>>>>>>>> it needs to instead be mapped to INVALID INPUT.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> /Flibble
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, no self reference.
>>>>>>>>>>>>>
>>>>>>>>>>>>> E just has a copy of the H that claim to be deciding it,
>>>>>>>>>>>>> not a "reference" to it. Turing Machines do not have the
>>>>>>>>>>>>> power to directly express a reference.
>>>>>>>>>>>>
>>>>>>>>>>>> Nope, if it isn't a self reference then it is infinite
>>>>>>>>>>>> copies all the way down so is the same category error
>>>>>>>>>>>> manifesting in a different way.
>>>>>>>>>>>>
>>>>>>>>>>>> /Flibble
>>>>>>>>>>>
>>>>>>>>>>> Only if the "decider" makes that happen, in which case it
>>>>>>>>>>> isn't actually a decider.
>>>>>>>>>>>
>>>>>>>>>>> If we assume a prospective decider exists, then the
>>>>>>>>>>> "Impossible" program is simple to make from it, and is
>>>>>>>>>>> given one copy of the description of itself, which is also
>>>>>>>>>>> simple to make.
>>>>>>>>>>>
>>>>>>>>>>> When run it makes a second copy of its description, and then
>>>>>>>>>>> calls the decider.
>>>>>>>>>>>
>>>>>>>>>>> After that, it is the deciders job to make the decision in
>>>>>>>>>>> finite time, by whatever method it wants. If it gets stuck
>>>>>>>>>>> in your infinite loop, the decider is just wrong.
>>>>>>>>>>>
>>>>>>>>>>> The proof shows that what ever answer the decider does give
>>>>>>>>>>> (if it gives one) will be wrong, and thus the decider
>>>>>>>>>>> doesn't meet the requirements.
>>>>>>>>>>>
>>>>>>>>>>> No "Self Reference" in sight there only a program being
>>>>>>>>>>> given a copy of something that just happens to be its own
>>>>>>>>>>> description.
>>>>>>>>>>>
>>>>>>>>>>> The only place we get any form of "Reference", is when we
>>>>>>>>>>> try to ANALYSE or DESIGN the H to try to meet the
>>>>>>>>>>> challenge. There the effect of the Self-Reference just lets
>>>>>>>>>>> us see that the task turns out be be impossible, so no such
>>>>>>>>>>> program exists.
>>>>>>>>>>
>>>>>>>>>> You are fractally wrong on all fronts: in the traditional
>>>>>>>>>> halting problem proofs based on [Strachey 1965] the program
>>>>>>>>>> is impossible not due to self reference or infinite copies
>>>>>>>>>> but because the input tries to do the opposite of what the
>>>>>>>>>> decider decides; the category error that I have identified
>>>>>>>>>> is different: it is an error of self reference and/or
>>>>>>>>>> infinite copies; it is an error related to the fact that the
>>>>>>>>>> input references a decider rather than being related to what
>>>>>>>>>> the input does with the decision result of a decider.
>>>>>>>>>>
>>>>>>>>>> /Flibble
>>>>>>>>>
>>>>>>>>> But the infinite copies is a error in the Decider, not in
>>>>>>>>> Strachey's program. The decider is SUPPOSED to be able to
>>>>>>>>> handle ANY input and answer in finite time, If an input
>>>>>>>>> causes it to make infinite copies, then the decided just
>>>>>>>>> doesn't meet its requirements.
>>>>>>>>>
>>>>>>>>> Turing Machine can ALWAYS be legally built based on another
>>>>>>>>> Turing Machine as a base. The only reason it wouldn't be
>>>>>>>>> allowed is if H isn't actually a Turing Machine, so it CAN'T
>>>>>>>>> be a category error if H is actualy a Turing Machine.
>>>>>>>>>
>>>>>>>>> All your declaration of a "Category Error" here is doing is
>>>>>>>>> admitting that your H can't actually be a Turing Machine, but
>>>>>>>>> must be of a HIGHER order logic system, which means H fails
>>>>>>>>> the requirement to be the needed decider.
>>>>>>>>
>>>>>>>> In which case we get infinite turning machines all the way
>>>>>>>> down: yet another manifestation of the category error I have
>>>>>>>> identified.
>>>>>>>>
>>>>>>>> /Flibble
>>>>>>>
>>>>>>> Where are infinite machines? There is ONE machine being run,
>>>>>>> either H or D, and it SIMULATING others, and if we get an
>>>>>>> infinite sequence of simulations we have just shown that H was
>>>>>>> defective because it failed to answer in finite time.
>>>>>>>
>>>>>>> This isn't a category error, but a design error in H.
>>>>>>>
>>>>>>> Note, when we start H, there is exactly two machines present in
>>>>>>> representation on the tape, and two is much smaller than
>>>>>>> infinity.
>>>>>>
>>>>>> Nope, if,
>>>>>>
>>>>>> a) H is a copy, and
>>>>>> b) H is a Turing Machine, and
>>>>>> c) D is an input into H, and
>>>>>> d) D references H, and
>>>>>> e) H references D,
>>>>>>
>>>>>> then (d) and (e) repeat ad infinitum so we get infinite Turing
>>>>>> Machines all the way down: a manifestation of the category error
>>>>>> I have identified.
>>>>>>
>>>>>> /Flibble
>>>>>>
>>>>>
>>>>> void E(void (*x)())
>>>>> {
>>>>>    H(x, x);
>>>>> }
>>>>>
>>>>> The point is
>>>>> that D correctly simulated by H would never reach its own last
>>>>> instruction and terminate normally after 1 to ∞ steps of correct
>>>>> simulation.
>>>>>
>>>>> When H returns 0 to main() it is indicating
>>>>>
>>>>> that D correctly simulated by H would never reach its own last
>>>>> instruction and terminate normally after 1 to ∞ steps of correct
>>>>> simulation.
>>>>>
>>>>
>>>> Except D is NOT correctly simulated by H, so that is a incorrect
>>>> statement. When it is correctly simulated by something other than
>>>> H, it will come to a final state, showing your statement is wrong.
>>>>
>>> In order for the simulation to actually be incorrect the execution
>>> trace of the simulated E must diverge from the behavior that the
>>> line-by-line x86 source-code of E specifies.
>>
>> Right, and since you simulation does NOT continue past the call to H,
>> it is "incorrect" in the sense that the actual code does continue
>> past that point, so it does not actually match the behavior of that
>> machine.
>>
>>>
>>> The first seven lines of the execution trace of the simulated E
>>> exactly match the behavior specified by the first seven lines of
>>> the x86 source code of E. This conclusively proves beyond all
>>> possible doubt that these first seven lines have been simulated
>>> correctly.
>>
>> Right, so H has correctly done a PARTIAL simulation of its input,
>> which does NOT prove the input is non-halting.
>>
>>>
>>> *H correctly determines that E never halts*
>>>
>>> void E(void (*x)())
>>> {
>>>   H(x, x);
>>> }
>>>
>>>
>>> int main()
>>> {
>>>   Output("Input_Halts = ", H(E, E));
>>> }
>>>
>>> _E()
>>> [000019d2] 55             push ebp
>>> [000019d3] 8bec           mov ebp,esp
>>> [000019d5] 8b4508         mov eax,[ebp+08]
>>> [000019d8] 50             push eax
>>> [000019d9] 8b4d08         mov ecx,[ebp+08]
>>> [000019dc] 51             push ecx
>>> [000019dd] e8b0f9ffff     call 00001392
>>> [000019e2] 83c408         add esp,+08
>>> [000019e5] 5d             pop ebp
>>> [000019e6] c3             ret
>>> Size in bytes:(0021) [000019e6]
>>>
>>> _main()
>>> [000019f2] 55             push ebp
>>> [000019f3] 8bec           mov ebp,esp
>>> [000019f5] 68d2190000     push 000019d2
>>> [000019fa] 68d2190000     push 000019d2
>>> [000019ff] e88ef9ffff     call 00001392
>>> [00001a04] 83c408         add esp,+08
>>> [00001a07] 50             push eax
>>> [00001a08] 6893060000     push 00000693
>>> [00001a0d] e8a0ecffff     call 000006b2
>>> [00001a12] 83c408         add esp,+08
>>> [00001a15] 33c0           xor eax,eax
>>> [00001a17] 5d             pop ebp
>>> [00001a18] c3             ret
>>> Size in bytes:(0039) [00001a18]
>>>
>>>  machine   stack     stack     machine    assembly
>>>  address   address   data      code       language
>>>  ========  ========  ========  =========  =============
>>> [000019f2][00102a7c][00000000] 55         push ebp
>>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
>>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
>>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
>>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H
>>>
>>> H: Begin Simulation   Execution Trace Stored at:112b28
>>> Address_of_H:1392
>>> [000019d2][00112b14][00112b18] 55         push ebp
>>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
>>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
>>> [000019d8][00112b10][000019d2] 50         push eax         // push E
>>> [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
>>> [000019dc][00112b0c][000019d2] 51         push ecx         // push E
>>> [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392    // call H
>>> H: Infinitely Recursive Simulation Detected Simulation Stopped
>>>
>>> H correctly reports that E correctly simulated by H cannot possibly
>>> reach its own final state at machine address [000019e6] and
>>> terminate normally in 1 to ∞ steps of correct simulation.
>>>
>>>
>>
>> So you are just admitting you don't understand the Halting Criteria.
>>
>> The fact that H stops its simulation before it gets to the end does
>> NOT prove that the machine being simulated, or a correct and complete
>> simultion of the input would be non-halting.
>>
>> Or, do you claim that you have correctly climbed Mount Everest since
>> ever step of you climb of it were correct?
>>
>> You are just proving you lack of understanding of the meaning of a
>> correct simulation.
>
> Olcott is correct and you are incorrect: you don't seem to understand
> what an (infinitely) recursive function actually entails.
>
> /Flibble
>

On Sat, 12 Nov 2022 13:24:00 -0500
Richard Damon <Richard@Damon-Family.org> wrote:

> On 11/12/22 1:16 PM, olcott wrote:
> > On 11/12/2022 11:59 AM, Richard Damon wrote:
> >> On 11/12/22 12:00 PM, olcott wrote:
> >>> On 11/12/2022 10:26 AM, Richard Damon wrote:
> >>>> On 11/12/22 10:50 AM, olcott wrote:
> >>>>> On 11/12/2022 9:03 AM, Mr Flibble wrote:
> >>>>>> On Sat, 12 Nov 2022 09:52:12 -0500
> >>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>
> >>>>>>> On 11/12/22 9:41 AM, Mr Flibble wrote:
> >>>>>>>> On Sat, 12 Nov 2022 09:32:23 -0500
> >>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>> On 11/12/22 9:09 AM, Mr Flibble wrote:
> >>>>>>>>>> On Fri, 11 Nov 2022 19:24:53 -0500
> >>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>>>> On 11/11/22 6:55 PM, Mr Flibble wrote:
> >>>>>>>>>>>> On Fri, 11 Nov 2022 18:25:58 -0500
> >>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>>>>>> On 11/11/22 4:54 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>> On Fri, 11 Nov 2022 16:44:49 -0500
> >>>>>>>>>>>>>> Richard Damon <Richard@Damon-Family.org> wrote:
> >>>>>>>>>>>>>>> On 11/11/22 4:15 PM, olcott wrote:
> >>>>>>>>>>>>>>>> On 11/11/2022 3:07 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>> On 11/11/22 2:39 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 11/11/2022 1:30 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>> On 11/11/22 2:16 PM, olcott wrote:
> >>>>>>>>>>>>>>>>>>>> On 11/11/2022 12:43 PM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>>>> On 11/11/22 1:36 PM, Mr Flibble wrote:
> >>>>>>>>>>>>>>>>>>>>>> It is my understanding that Olcott has blocked
> >>>>>>>>>>>>>>>>>>>>>> you and I would have thought given your
> >>>>>>>>>>>>>>>>>>>>>> intelligence you would also understand that.
> >>>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I don't think he has actually blocked me, just
> >>>>>>>>>>>>>>>>>>>>> mostly ignores me.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> I say this because at times he seems to respond
> >>>>>>>>>>>>>>>>>>>>> to what I say, even if not in a direct reply,
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Also, when someone like you replies, even if he
> >>>>>>>>>>>>>>>>>>>>> has blocked me, he will still see me.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> More importantly, If anyone naive wanders into
> >>>>>>>>>>>>>>>>>>>>> the archives, I want enough evidence to be
> >>>>>>>>>>>>>>>>>>>>> around to point out his errors.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> Note also, my longer replies shows what I know
> >>>>>>>>>>>>>>>>>>>>> and provide reasoning behind the claims,
> >>>>>>>>>>>>>>>>>>>>> showing the Truth.
> >>>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> His short claims, and guff replies just show
> >>>>>>>>>>>>>>>>>>>>> that he doesn't actually know what he is
> >>>>>>>>>>>>>>>>>>>>> talking about, and reveals his ignorance. If he
> >>>>>>>>>>>>>>>>>>>>> tries to put his explanation into explicit
> >>>>>>>>>>>>>>>>>>>>> words, his errors become very apparent, I think
> >>>>>>>>>>>>>>>>>>>>> even to him, so he just refuses.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> You always use the strawman deception as your
> >>>>>>>>>>>>>>>>>>>> only basis. Naive readers will never notice
> >>>>>>>>>>>>>>>>>>>> this, yet naive readers are not in my target
> >>>>>>>>>>>>>>>>>>>> audience.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> No, because *I* use the actual definition of a
> >>>>>>>>>>>>>>>>>>> Halting Decider.
> >>>>>>>>>>>>>>>>>> Anyone that accepts the definition of a universal
> >>>>>>>>>>>>>>>>>> Turing machine (UTM) knows that the behavior of D
> >>>>>>>>>>>>>>>>>> correctly simulated by H provides H with a correct
> >>>>>>>>>>>>>>>>>> basis for its halt status decision.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> But only if H DOES correctly simulate its input.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> void E(void (*x)())
> >>>>>>>>>>>>>>>> {
> >>>>>>>>>>>>>>>>         H(x, x);
> >>>>>>>>>>>>>>>> }
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Any H that does abort its simulation to prevent the
> >>>>>>>>>>>>>>>> infinite
> >>>>>>>>>>>>>>>> execution of E is correct to report non-halting. No
> >>>>>>>>>>>>>>>> shell game can correctly deny this.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> Any H that does aborts its simulation is INCORRECT
> >>>>>>>>>>>>>>> because the CORRECT simulation, as will the diret
> >>>>>>>>>>>>>>> exectuion, will halt. Note, such an H doesn't do a
> >>>>>>>>>>>>>>> correct simulation, so any
> >>>>>>>>>>>>>>> arguement based on it doing so it just WRONG.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> The need to abort the simulation is due to the self
> >>>>>>>>>>>>>> reference category error present in the proof; what
> >>>>>>>>>>>>>> Olcott is getting wrong is the mapping of the need to
> >>>>>>>>>>>>>> abort the simulation to a halt decision of
> >>>>>>>>>>>>>> non-halting; it needs to instead be mapped to
> >>>>>>>>>>>>>> INVALID INPUT.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> /Flibble
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> Nope, no self reference.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> E just has a copy of the H that claim to be deciding
> >>>>>>>>>>>>> it, not a "reference" to it. Turing Machines do not
> >>>>>>>>>>>>> have the power to directly express a reference.
> >>>>>>>>>>>>
> >>>>>>>>>>>> Nope, if it isn't a self reference then it is infinite
> >>>>>>>>>>>> copies all the way down so is the same category error
> >>>>>>>>>>>> manifesting in a different way.
> >>>>>>>>>>>>
> >>>>>>>>>>>> /Flibble
> >>>>>>>>>>>
> >>>>>>>>>>> Only if the "decider" makes that happen, in which case it
> >>>>>>>>>>> isn't actually a decider.
> >>>>>>>>>>>
> >>>>>>>>>>> If we assume a prospective decider exists, then the
> >>>>>>>>>>> "Impossible" program is simple to make from it, and is
> >>>>>>>>>>> given one copy of the description of itself, which is
> >>>>>>>>>>> also simple to make.
> >>>>>>>>>>>
> >>>>>>>>>>> When run it makes a second copy of its description, and
> >>>>>>>>>>> then calls the decider.
> >>>>>>>>>>>
> >>>>>>>>>>> After that, it is the deciders job to make the decision
> >>>>>>>>>>> in finite
> >>>>>>>>>>> time, by whatever method it wants. If it gets stuck in
> >>>>>>>>>>> your infinite loop, the decider is just wrong.
> >>>>>>>>>>>
> >>>>>>>>>>> The proof shows that what ever answer the decider does
> >>>>>>>>>>> give (if it gives one) will be wrong, and thus the
> >>>>>>>>>>> decider doesn't meet the requirements.
> >>>>>>>>>>>
> >>>>>>>>>>> No "Self Reference" in sight there only a program being
> >>>>>>>>>>> given a copy of something that just happens to be its own
> >>>>>>>>>>> description.
> >>>>>>>>>>>
> >>>>>>>>>>> The only place we get any form of "Reference", is when we
> >>>>>>>>>>> try to ANALYSE or DESIGN the H to try to meet the
> >>>>>>>>>>> challenge. There the effect of the Self-Reference just
> >>>>>>>>>>> lets us see that the task turns
> >>>>>>>>>>> out be be impossible, so no such program exists.
> >>>>>>>>>>
> >>>>>>>>>> You are fractally wrong on all fronts: in the traditional
> >>>>>>>>>> halting problem proofs based on [Strachey 1965] the
> >>>>>>>>>> program is impossible not due to self reference or
> >>>>>>>>>> infinite copies but because the input
> >>>>>>>>>> tries to do the opposite of what the decider decides; the
> >>>>>>>>>> category
> >>>>>>>>>> error that I have identified is different: it is an error
> >>>>>>>>>> of self reference and/or infinite copies; it is an error
> >>>>>>>>>> related to the fact that the input references a decider
> >>>>>>>>>> rather than being related
> >>>>>>>>>> to what the input does with the decision result of a
> >>>>>>>>>> decider.
> >>>>>>>>>>
> >>>>>>>>>> /Flibble
> >>>>>>>>>
> >>>>>>>>> But the infinite copies is a error in the Decider, not in
> >>>>>>>>> Strachey's program. The decider is SUPPOSED to be able to
> >>>>>>>>> handle ANY input and answer in finite time, If an input
> >>>>>>>>> causes it to make infinite copies, then the decided just
> >>>>>>>>> doesn't meet its requirements.
> >>>>>>>>>
> >>>>>>>>> Turing Machine can ALWAYS be legally built based on another
> >>>>>>>>> Turing Machine as a base. The only reason it wouldn't be
> >>>>>>>>> allowed is if H isn't actually a Turing Machine, so it
> >>>>>>>>> CAN'T be a category error if H is actualy a Turing Machine.
> >>>>>>>>>
> >>>>>>>>> All your declaration of a "Category Error" here is doing is
> >>>>>>>>> admitting that your H can't actually be a Turing Machine,
> >>>>>>>>> but must be of a HIGHER order logic system, which means H
> >>>>>>>>> fails the requirement to be the needed decider.
> >>>>>>>>
> >>>>>>>> In which case we get infinite turning machines all the way
> >>>>>>>> down: yet
> >>>>>>>> another manifestation of the category error I have
> >>>>>>>> identified.
> >>>>>>>>
> >>>>>>>> /Flibble
> >>>>>>>
> >>>>>>> Where are infinite machines? There is ONE machine being run,
> >>>>>>> either H
> >>>>>>> or D, and it SIMULATING others, and if we get an infinite
> >>>>>>> sequence of
> >>>>>>> simulations we have just shown that H was defective because
> >>>>>>> it failed
> >>>>>>> to answer in finite time.
> >>>>>>>
> >>>>>>> This isn't a category error, but a design error in H.
> >>>>>>>
> >>>>>>> Note, when we start H, there is exactly two machines present
> >>>>>>> in representation on the tape, and two is much smaller than
> >>>>>>> infinity.
> >>>>>>
> >>>>>> Nope, if,
> >>>>>>
> >>>>>> a) H is a copy, and
> >>>>>> b) H is a Turing Machine, and
> >>>>>> c) D is an input into H, and
> >>>>>> d) D references H, and
> >>>>>> e) H references D,
> >>>>>>
> >>>>>> then (d) and (e) repeat ad infinitum so we get infinite Turing
> >>>>>> Machines
> >>>>>> all the way down: a manifestation of the category error I have
> >>>>>> identified.
> >>>>>>
> >>>>>> /Flibble
> >>>>>>
> >>>>>
> >>>>> void E(void (*x)())
> >>>>> {
> >>>>>    H(x, x);
> >>>>> }
> >>>>>
> >>>>> The point is
> >>>>> that D correctly simulated by H would never reach its own last
> >>>>> instruction and terminate normally after 1 to ∞ steps of
> >>>>> correct simulation.
> >>>>>
> >>>>> When H returns 0 to main() it is indicating
> >>>>>
> >>>>> that D correctly simulated by H would never reach its own last
> >>>>> instruction and terminate normally after 1 to ∞ steps of
> >>>>> correct simulation.
> >>>>>
> >>>>
> >>>> Except D is NOT correctly simulated by H, so that is a incorrect
> >>>> statement. When it is correctly simulated by something other
> >>>> than H, it will come to a final state, showing your statement is
> >>>> wrong.
> >>> In order for the simulation to actually be incorrect the
> >>> execution trace of the simulated E must diverge from the behavior
> >>> that the line-by-line x86 source-code of E specifies.
> >>
> >> Right, and since you simulation does NOT continue past the call to
> >> H, it is "incorrect" in the sense that the actual code does
> >> continue past that point, so it does not actually match the
> >> behavior of that machine.
> >>>
> >>> The first seven lines of the execution trace of the simulated E
> >>> exactly match the behavior specified by the first seven lines of
> >>> the x86 source code of E. This conclusively proves beyond all
> >>> possible doubt that these first seven lines have been simulated
> >>> correctly.
> >>
> >> Right, so H has correctly done a PARTIAL simulation of its input,
> >> which does NOT prove the input is non-halting.
> >>
> >>>
> >>> *H correctly determines that E never halts*
> >>>
> >>> void E(void (*x)())
> >>> {
> >>>    H(x, x);
> >>> }
> >>>
> >>>
> >>> int main()
> >>> {
> >>>    Output("Input_Halts = ", H(E, E));
> >>> }
> >>>
> >>> _E()
> >>> [000019d2] 55             push ebp
> >>> [000019d3] 8bec           mov ebp,esp
> >>> [000019d5] 8b4508         mov eax,[ebp+08]
> >>> [000019d8] 50             push eax
> >>> [000019d9] 8b4d08         mov ecx,[ebp+08]
> >>> [000019dc] 51             push ecx
> >>> [000019dd] e8b0f9ffff     call 00001392
> >>> [000019e2] 83c408         add esp,+08
> >>> [000019e5] 5d             pop ebp
> >>> [000019e6] c3             ret
> >>> Size in bytes:(0021) [000019e6]
> >>>
> >>> _main()
> >>> [000019f2] 55             push ebp
> >>> [000019f3] 8bec           mov ebp,esp
> >>> [000019f5] 68d2190000     push 000019d2
> >>> [000019fa] 68d2190000     push 000019d2
> >>> [000019ff] e88ef9ffff     call 00001392
> >>> [00001a04] 83c408         add esp,+08
> >>> [00001a07] 50             push eax
> >>> [00001a08] 6893060000     push 00000693
> >>> [00001a0d] e8a0ecffff     call 000006b2
> >>> [00001a12] 83c408         add esp,+08
> >>> [00001a15] 33c0           xor eax,eax
> >>> [00001a17] 5d             pop ebp
> >>> [00001a18] c3             ret
> >>> Size in bytes:(0039) [00001a18]
> >>>
> >>>   machine   stack     stack     machine    assembly
> >>>   address   address   data      code       language
> >>>   ========  ========  ========  =========  ============> >>> [000019f2][00102a7c][00000000] 55         push ebp
> >>> [000019f3][00102a7c][00000000] 8bec       mov ebp,esp
> >>> [000019f5][00102a78][000019d2] 68d2190000 push 000019d2 // push E
> >>> [000019fa][00102a74][000019d2] 68d2190000 push 000019d2 // push E
> >>> [000019ff][00102a70][00001a04] e88ef9ffff call 00001392 // call H
> >>>
> >>> H: Begin Simulation   Execution Trace Stored at:112b28
> >>> Address_of_H:1392
> >>> [000019d2][00112b14][00112b18] 55         push ebp
> >>> [000019d3][00112b14][00112b18] 8bec       mov ebp,esp
> >>> [000019d5][00112b14][00112b18] 8b4508     mov eax,[ebp+08]
> >>> [000019d8][00112b10][000019d2] 50         push eax         //
> >>> push E [000019d9][00112b10][000019d2] 8b4d08     mov ecx,[ebp+08]
> >>> [000019dc][00112b0c][000019d2] 51         push ecx         //
> >>> push E [000019dd][00112b08][000019e2] e8b0f9ffff call 00001392
> >>> // call H H: Infinitely Recursive Simulation Detected Simulation
> >>> Stopped
> >>>
> >>> H correctly reports that E correctly simulated by H cannot
> >>> possibly reach its own final state at machine address [000019e6]
> >>> and terminate normally in 1 to ∞ steps of correct simulation.
> >>>
> >>>
> >>
> >> So you are just admitting you don't understand the Halting
> >> Criteria.
> >>
> >> The fact that H stops its simulation before it gets to the end
> >> does NOT prove that the machine being simulated, or a correct and
> >> complete simultion of the input would be non-halting.
> > We must handle only one point at a time because you are easily
> > overwhelmed. You usually cannot even handle one point at a time
> > until this point is repeated 20 or more times.
> >
> > The fact that the line-by-line execution trace of the first seven
> > instructions E simulated by H exactly match the behavior specified
> > by the first seven instructions of the x86 source-code of E
> > conclusively proves that these first seven instructions are
> > simulated correctly.
>
> No, that says that H did a correct PARTIAL simulation of the input.
> You seem to be INTENTIONALLY using deceptive terminology to spread
> you lies.
>
> So, I suppose you can correctly say that the input doesn't stop
> within its first 7 instructions, but that doesn't mean anything.
>
> Since you make a claim about a COMPLETE simulation (the it will never
> end) you need to establish THAT fact (and you can't change the input
> to do it, which includes the H the E calls).
>
> YOU FAIL
>
> You show that you don't understand what you are talking about and
> seem to actually think that you are proving something by using wrong
> defintions.
>
> You are just showing how stupid you are.