On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com wrote:
> You just don't understand how logic works.
People in glass houses shouldn’t throw rocks.

The “law” of excluded middle in Classical logic (P v not P) is the exact same thing as a decision problem!

Unless you are in the possession of a proof showing us exactly which one holds you are, in fact talking about possibilities, not actualities.

You are talking about an Either monad - yet another (unspecified!) computation.

On 9/2/22 10:49 PM, olcott wrote:
> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>
>> On 9/2/22 10:17 PM, olcott wrote:
>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string input to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) is the representation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when H(P,P)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulates its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> this simulation would stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without being aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing proves
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulation does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> otherwise ever stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> real code on real machines empirical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> testing is 100% reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl Test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't designed to the requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it keeps
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software engineering is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> going to buy that bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply commenting out the line of code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does the abort prevents the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation from ever stopping that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not stop without the abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance. Since
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you also edited the program under test
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when you did that, you invalidated the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with those
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with correct complete certainty that when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> commenting out the code the does the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> causes the the simulation to never stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that it is only the abort that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will agree
>>>>>>>>>>>>>>>>>>>>>>>>>>> with me and disagree with your weasel word
>>>>>>>>>>>>>>>>>>>>>>>>>>> double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input calls
>>>>>>>>>>>>>>>>>>>>>>>>>> the decider, so editing the decider changes
>>>>>>>>>>>>>>>>>>>>>>>>>> the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is going to
>>>>>>>>>>>>>>>>>>>>>>>>> know that we can test that X causes Y by
>>>>>>>>>>>>>>>>>>>>>>>>> removing only X and Y stops happening.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the line of
>>>>>>>>>>>>>>>>>>>>>>> code that does the abort is commented out and
>>>>>>>>>>>>>>>>>>>>>>> this results in the correctly simulated input to
>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never stopping that this does not mean
>>>>>>>>>>>>>>>>>>>>>>> that that it is only the abort that causes the
>>>>>>>>>>>>>>>>>>>>>>> simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus your
>>>>>>>>>>>>>>>>>>>>>> experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that H(P,P)
>>>>>>>>>>>>>>>>>>>>> stops running when H is allowed to abort its
>>>>>>>>>>>>>>>>>>>>> simulation of P
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its simulation
>>>>>>>>>>>>>>>>>>>> of P (no "allowed" in there, it HAS to abort its
>>>>>>>>>>>>>>>>>>>> simulation or it isn't the H you have defined)
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that H(P,P)
>>>>>>>>>>>>>>>>>>>>> never stops running when H is *NOT* allowed to
>>>>>>>>>>>>>>>>>>>>> abort its simulation of P
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that has
>>>>>>>>>>>>>>>>>>>> been defined.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code in a
>>>>>>>>>>>>>>>>>>> function the compiler absolutely will not change the
>>>>>>>>>>>>>>>>>>> name of this function and you know this so why lie?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't change
>>>>>>>>>>>>>>>>>> the behavior of the function?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then this
>>>>>>>>>>>>>>>>> transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the simulator,
>>>>>>>>>>>>>>>> so you changed P which isn't allowed
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>>>>> conclusively proves that a pure simulation of the input
>>>>>>>>>>>>>>>>> to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Every competent software engineer knows that my proof is
>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have checked with a couple of very competent software
>>>>>>>>>>>>>> engineers I know, and none of them agree with you, so you
>>>>>>>>>>>>>> claim is proven false by example. You are making the
>>>>>>>>>>>>>> fallacy of Ad Populum without even having the populum.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That you play silly games with naming conventions is just
>>>>>>>>>>>>>>> like Zeno's paradox that "proves" it is impossible to
>>>>>>>>>>>>>>> cross the room to get to the other side.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>> conventions" just proves you don't understand what you are
>>>>>>>>>>>>>> talking about.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Zeno mathematically proved that two items cannot possibly
>>>>>>>>>>>>> touch thus when two items touch the proof is refuted.
>>>>>>>>>>>>
>>>>>>>>>>>> No, Zeno made the error that an infintly long sum might sum
>>>>>>>>>>>> to a finite value.
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When we make one single change to H, removing its ability
>>>>>>>>>>>>> to abort the simulation of its input then this transforms
>>>>>>>>>>>>> the original H into a pure simulator.
>>>>>>>>>>>>
>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when you
>>>>>>>>>>>> processs the MODIFIED P that you get from that change you
>>>>>>>>>>>> haven't proven anything about the original
>>>>>>>>>>>>
>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>
>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>
>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>> conclusively proves that a pure simulation of the input to
>>>>>>>>>>>>> H(P,P) never stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, because you CAN'T run H and have it never stop running,
>>>>>>>>>>>> becaue you have DEFINED (by publishing the code for the H
>>>>>>>>>>>> you claim is correct).
>>>>>>>>>>>
>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>> H(P,P) ever stops running is that H aborts the simulation of
>>>>>>>>>>> its input.
>>>>>>>>>>
>>>>>>>>>> Sort of.
>>>>>>>>> A simulating halt decider is required to correctly predict
>>>>>>>>> whether or not the hypothetical case of its correct and
>>>>>>>>> complete simulation of its input would reach the final state of
>>>>>>>>> this input.
>>>>>>>>
>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so you fail
>>>>>>>>
>>>>>>>> A Halt Decider is required to decide on the ACTUAL BEHAVIOR of
>>>>>>>> the ACTUAL MACHINE that the input represents.
>>>>>>>>
>>>>>>>
>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>> over-ruled and superseded by the behavior of the correct and
>>>>>>> complete simulation of this input at the same point in the
>>>>>>> execution trace as H.
>>>>>>>
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>>> In other words: Does H(P,P) have to abort its simulation of its
>>>>>>> input to prevent the infinite execution of this input?
>>>>>>
>>>>>>
>>>>>> WRONG
>>>>>>>
>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>
>>>>>>> Means that this correctly simulated input cannot reach its own
>>>>>>> final state, thus is non-halting.
>>>>>>>
>>>>>>
>>>>>> WRONG.
>>>>>>
>>>>>> If you won't go by the oficial definitions, your H just isn't a
>>>>>> Halt Decider.
>>>>>>
>>>>>
>>>>> If the official definitions are self-contradictory then at least
>>>>> one of them must be rejected as incorrect.
>>>>
>>>> And what is contradictory about it?
>>>>
>>>> A given Turing Machine M applied to an input d will either Halt or Not.
>>>>
>>>> THe Halt Decider, when given a
>>>>
>>>>
>>>>>
>>>>>> PERIOD.
>>>>>>
>>>>>> Acting like a two year old won't change that.
>>>>>>
>>>>>> You won't name a specific thing that I say that is wrong, just
>>>>>> that we need you use your definitions that don't match the actual
>>>>>> ones.
>>>>>>
>>>>>> That shows you are just stupid and ignorant.
>>>>>>
>>>>>> YOU FAIL.
>>>>>
>>>>> That H(P,P) must abort its simulation of its input means that a
>>>>> correct and complete simulation of this input by H would never stop
>>>>> running.
>>>>
>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>
>>> A correct halt deciding criteria for every halt decider is the
>>> correct prediction that the correct and complete simulation of its
>>> input would never reach the final state of this simulated input.
>>
>> No, it is that the actual machine will halt or not.
>
> Unless you reject the notion of a UTM what I said is true.
> Do you reject the notion of a UTM?
>

On 9/3/22 12:35 AM, Skep Dick wrote:
> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com wrote:
>> You just don't understand how logic works.
> People in glass houses shouldn’t throw rocks.
>
> The “law” of excluded middle in Classical logic (P v not P) is the exact same thing as a decision problem!
>
> Unless you are in the possession of a proof showing us exactly which one holds you are, in fact talking about possibilities, not actualities.
>
> You are talking about an Either monad - yet another (unspecified!) computation.

You are worse the Olcott. He at least beleives the crap he talks about,
I'm not so sure you do.

If you think he is actually using logic, you have just condemned your
ideas to to trash pile.

On Saturday, 3 September 2022 at 12:32:13 UTC+2, richar...@gmail.com wrote:
> On 9/3/22 12:35 AM, Skep Dick wrote:
> > On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com wrote:
> >> You just don't understand how logic works.
> > People in glass houses shouldn’t throw rocks.
> >
> > The “law” of excluded middle in Classical logic (P v not P) is the exact same thing as a decision problem!
> >
> > Unless you are in the possession of a proof showing us exactly which one holds you are, in fact talking about possibilities, not actualities.
> >
> > You are talking about an Either monad - yet another (unspecified!) computation.
> You are worse the Olcott. He at least beleives the crap he talks about,
> I'm not so sure you do.
>
> If you think he is actually using logic, you have just condemned your
> ideas to to trash pile.

From where I am looking you seem to think that logic is a monolith.

Perhaps that is where all of this confusion comes from? You only know one logic.

On Saturday, September 3, 2022 at 2:54:54 AM UTC+1, olcott wrote:
> On 9/2/2022 7:46 PM, Richard Damon wrote:
> > If you won't go by the oficial definitions, your H just isn't a Halt
> > Decider.
> >
> If the official definitions are self-contradictory then at least one of
> them must be rejected as incorrect.

No, you are wrong here. The official definition of a halt decider is self-contradictory, in that it is impossible to build anything which meets the definition. This has been proved.

You are arguing that the proof is not correct. However, you feel free to change or reject the definition so you are not talking about the same subject.

On 9/3/2022 7:00 AM, Paul N wrote:
> On Saturday, September 3, 2022 at 2:54:54 AM UTC+1, olcott wrote:
>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>> If you won't go by the oficial definitions, your H just isn't a Halt
>>> Decider.
>>>
>> If the official definitions are self-contradictory then at least one of
>> them must be rejected as incorrect.
>
> No, you are wrong here. The official definition of a halt decider is self-contradictory, in that it is impossible to build anything which meets the definition. This has been proved.

That is not the way truth works mate. If the official definitions are
self-contradictory then I have also had new insight on that another
aspect of computer science is incorrect.

>
> You are arguing that the proof is not correct. However, you feel free to change or reject the definition so you are not talking about the same subject.
--
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 9/3/2022 5:22 AM, Richard Damon wrote:
> On 9/2/22 10:49 PM, olcott wrote:
>> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>>
>>> On 9/2/22 10:17 PM, olcott wrote:
>>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) is the representation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input this simulation would stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without being aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not otherwise ever stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> real code on real machines empirical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> testing is 100% reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl Test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't designed to the requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keeps running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software engineering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is going to buy that bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply commenting out the line of code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does the abort prevents the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation from ever stopping that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not stop without the abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you also edited the program under
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test when you did that, you invalidated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with those
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with correct complete certainty that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when commenting out the code the does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort causes the the simulation to never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop that it is only the abort that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will agree
>>>>>>>>>>>>>>>>>>>>>>>>>>>> with me and disagree with your weasel word
>>>>>>>>>>>>>>>>>>>>>>>>>>>> double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input calls
>>>>>>>>>>>>>>>>>>>>>>>>>>> the decider, so editing the decider changes
>>>>>>>>>>>>>>>>>>>>>>>>>>> the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is going to
>>>>>>>>>>>>>>>>>>>>>>>>>> know that we can test that X causes Y by
>>>>>>>>>>>>>>>>>>>>>>>>>> removing only X and Y stops happening.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the line of
>>>>>>>>>>>>>>>>>>>>>>>> code that does the abort is commented out and
>>>>>>>>>>>>>>>>>>>>>>>> this results in the correctly simulated input to
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never stopping that this does not mean
>>>>>>>>>>>>>>>>>>>>>>>> that that it is only the abort that causes the
>>>>>>>>>>>>>>>>>>>>>>>> simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus your
>>>>>>>>>>>>>>>>>>>>>>> experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that H(P,P)
>>>>>>>>>>>>>>>>>>>>>> stops running when H is allowed to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation of P
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its simulation
>>>>>>>>>>>>>>>>>>>>> of P (no "allowed" in there, it HAS to abort its
>>>>>>>>>>>>>>>>>>>>> simulation or it isn't the H you have defined)
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that H(P,P)
>>>>>>>>>>>>>>>>>>>>>> never stops running when H is *NOT* allowed to
>>>>>>>>>>>>>>>>>>>>>> abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that has
>>>>>>>>>>>>>>>>>>>>> been defined.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code in a
>>>>>>>>>>>>>>>>>>>> function the compiler absolutely will not change the
>>>>>>>>>>>>>>>>>>>> name of this function and you know this so why lie?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't
>>>>>>>>>>>>>>>>>>> change the behavior of the function?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then this
>>>>>>>>>>>>>>>>>> transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the simulator,
>>>>>>>>>>>>>>>>> so you changed P which isn't allowed
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>>>>>> conclusively proves that a pure simulation of the
>>>>>>>>>>>>>>>>>> input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Every competent software engineer knows that my proof is
>>>>>>>>>>>>>>>> correct.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have checked with a couple of very competent software
>>>>>>>>>>>>>>> engineers I know, and none of them agree with you, so you
>>>>>>>>>>>>>>> claim is proven false by example. You are making the
>>>>>>>>>>>>>>> fallacy of Ad Populum without even having the populum.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That you play silly games with naming conventions is
>>>>>>>>>>>>>>>> just like Zeno's paradox that "proves" it is impossible
>>>>>>>>>>>>>>>> to cross the room to get to the other side.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>>> conventions" just proves you don't understand what you
>>>>>>>>>>>>>>> are talking about.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Zeno mathematically proved that two items cannot possibly
>>>>>>>>>>>>>> touch thus when two items touch the proof is refuted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, Zeno made the error that an infintly long sum might sum
>>>>>>>>>>>>> to a finite value.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When we make one single change to H, removing its ability
>>>>>>>>>>>>>> to abort the simulation of its input then this transforms
>>>>>>>>>>>>>> the original H into a pure simulator.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when you
>>>>>>>>>>>>> processs the MODIFIED P that you get from that change you
>>>>>>>>>>>>> haven't proven anything about the original
>>>>>>>>>>>>>
>>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>>
>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>> conclusively proves that a pure simulation of the input to
>>>>>>>>>>>>>> H(P,P) never stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> No, because you CAN'T run H and have it never stop running,
>>>>>>>>>>>>> becaue you have DEFINED (by publishing the code for the H
>>>>>>>>>>>>> you claim is correct).
>>>>>>>>>>>>
>>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>>> H(P,P) ever stops running is that H aborts the simulation of
>>>>>>>>>>>> its input.
>>>>>>>>>>>
>>>>>>>>>>> Sort of.
>>>>>>>>>> A simulating halt decider is required to correctly predict
>>>>>>>>>> whether or not the hypothetical case of its correct and
>>>>>>>>>> complete simulation of its input would reach the final state
>>>>>>>>>> of this input.
>>>>>>>>>
>>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so you fail
>>>>>>>>>
>>>>>>>>> A Halt Decider is required to decide on the ACTUAL BEHAVIOR of
>>>>>>>>> the ACTUAL MACHINE that the input represents.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>>> over-ruled and superseded by the behavior of the correct and
>>>>>>>> complete simulation of this input at the same point in the
>>>>>>>> execution trace as H.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>>> In other words: Does H(P,P) have to abort its simulation of its
>>>>>>>> input to prevent the infinite execution of this input?
>>>>>>>
>>>>>>>
>>>>>>> WRONG
>>>>>>>>
>>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>
>>>>>>>> Means that this correctly simulated input cannot reach its own
>>>>>>>> final state, thus is non-halting.
>>>>>>>>
>>>>>>>
>>>>>>> WRONG.
>>>>>>>
>>>>>>> If you won't go by the oficial definitions, your H just isn't a
>>>>>>> Halt Decider.
>>>>>>>
>>>>>>
>>>>>> If the official definitions are self-contradictory then at least
>>>>>> one of them must be rejected as incorrect.
>>>>>
>>>>> And what is contradictory about it?
>>>>>
>>>>> A given Turing Machine M applied to an input d will either Halt or
>>>>> Not.
>>>>>
>>>>> THe Halt Decider, when given a
>>>>>
>>>>>
>>>>>>
>>>>>>> PERIOD.
>>>>>>>
>>>>>>> Acting like a two year old won't change that.
>>>>>>>
>>>>>>> You won't name a specific thing that I say that is wrong, just
>>>>>>> that we need you use your definitions that don't match the actual
>>>>>>> ones.
>>>>>>>
>>>>>>> That shows you are just stupid and ignorant.
>>>>>>>
>>>>>>> YOU FAIL.
>>>>>>
>>>>>> That H(P,P) must abort its simulation of its input means that a
>>>>>> correct and complete simulation of this input by H would never
>>>>>> stop running.
>>>>>
>>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>>
>>>> A correct halt deciding criteria for every halt decider is the
>>>> correct prediction that the correct and complete simulation of its
>>>> input would never reach the final state of this simulated input.
>>>
>>> No, it is that the actual machine will halt or not.
>>
>> Unless you reject the notion of a UTM what I said is true.
>> Do you reject the notion of a UTM?
>>
>
> Nope, you just don't eem to know what a UTM actually is.
>

On 9/3/2022 5:32 AM, Richard Damon wrote:
> On 9/3/22 12:35 AM, Skep Dick wrote:
>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com
>> wrote:
>>> You just don't understand how logic works.
>> People in glass houses shouldn’t throw rocks.
>>
>> The “law” of excluded middle in Classical logic (P v not P) is the
>> exact same thing as a decision problem!
>>
>> Unless you are in the possession of a proof showing us exactly which
>> one holds you are, in fact talking about possibilities, not actualities.
>>
>> You are talking about an Either monad - yet another (unspecified!)
>> computation.
>
> You are worse the Olcott. He at least beleives the crap he talks about,
> I'm not so sure you do.
>
> If you think he is actually using logic, you have just condemned your
> ideas to to trash pile.

Paul N believes that two contradictory statements can both be true.

--
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 Saturday, September 3, 2022 at 1:43:43 PM UTC+1, olcott wrote:
> On 9/3/2022 7:00 AM, Paul N wrote:
> > On Saturday, September 3, 2022 at 2:54:54 AM UTC+1, olcott wrote:
> >> On 9/2/2022 7:46 PM, Richard Damon wrote:
> >>> If you won't go by the oficial definitions, your H just isn't a Halt
> >>> Decider.
> >>>
> >> If the official definitions are self-contradictory then at least one of
> >> them must be rejected as incorrect.
> >
> > No, you are wrong here. The official definition of a halt decider is self-contradictory, in that it is impossible to build anything which meets the definition. This has been proved.
> That is not the way truth works mate. If the official definitions are
> self-contradictory then I have also had new insight on that another
> aspect of computer science is incorrect.

So you are not disputing that official definition of a halt decider is self-contradictory?

It's not immediately obvious, but it can be proved that the definition is self-contradictory. You're not disputing that proof?

On 9/3/2022 6:42 AM, Skep Dick wrote:
> On Saturday, 3 September 2022 at 12:32:13 UTC+2, richar...@gmail.com wrote:
>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com wrote:
>>>> You just don't understand how logic works.
>>> People in glass houses shouldn’t throw rocks.
>>>
>>> The “law” of excluded middle in Classical logic (P v not P) is the exact same thing as a decision problem!
>>>
>>> Unless you are in the possession of a proof showing us exactly which one holds you are, in fact talking about possibilities, not actualities.
>>>
>>> You are talking about an Either monad - yet another (unspecified!) computation.
>> You are worse the Olcott. He at least beleives the crap he talks about,
>> I'm not so sure you do.
>>
>> If you think he is actually using logic, you have just condemned your
>> ideas to to trash pile.
>
> From where I am looking you seem to think that logic is a monolith.
>
> Perhaps that is where all of this confusion comes from? You only know one logic.

Correct reasoning requires applying *ONLY* truth preserving operations
to a set of premises, making the conclusion a necessary consequence of
the truth of the premises. The principle of explosion breaks that.

--
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 9/3/22 7:42 AM, Skep Dick wrote:
> On Saturday, 3 September 2022 at 12:32:13 UTC+2, richar...@gmail.com wrote:
>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com wrote:
>>>> You just don't understand how logic works.
>>> People in glass houses shouldn’t throw rocks.
>>>
>>> The “law” of excluded middle in Classical logic (P v not P) is the exact same thing as a decision problem!
>>>
>>> Unless you are in the possession of a proof showing us exactly which one holds you are, in fact talking about possibilities, not actualities.
>>>
>>> You are talking about an Either monad - yet another (unspecified!) computation.
>> You are worse the Olcott. He at least beleives the crap he talks about,
>> I'm not so sure you do.
>>
>> If you think he is actually using logic, you have just condemned your
>> ideas to to trash pile.
>
> From where I am looking you seem to think that logic is a monolith.
>
> Perhaps that is where all of this confusion comes from? You only know one logic.

I suppose it depends on what you mean by that. "Logic" has few basic
universal properties, to which we add Logic Model operations relating to
our Model of Logic, and then we add the Axiom based on the Field we are
working in.

Note, once you define the Field of Operation that you working in, you
have chosen your Axioms and Logic Model.

Sometimes in a Application Field we can be investigating if alternate
Models might be useful to see if other approaches might be useful, but
any given statement will be attached to a particular Model (and we might
be comparing the results of two similar statements in different Models).

Trying to talk about the Logic of a Field without defining your Model is
just worthless, as nothing has meaning.

On 9/3/2022 7:50 AM, Paul N wrote:
> On Saturday, September 3, 2022 at 1:43:43 PM UTC+1, olcott wrote:
>> On 9/3/2022 7:00 AM, Paul N wrote:
>>> On Saturday, September 3, 2022 at 2:54:54 AM UTC+1, olcott wrote:
>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>> If you won't go by the oficial definitions, your H just isn't a Halt
>>>>> Decider.
>>>>>
>>>> If the official definitions are self-contradictory then at least one of
>>>> them must be rejected as incorrect.
>>>
>>> No, you are wrong here. The official definition of a halt decider is self-contradictory, in that it is impossible to build anything which meets the definition. This has been proved.
>> That is not the way truth works mate. If the official definitions are
>> self-contradictory then I have also had new insight on that another
>> aspect of computer science is incorrect.
>
> So you are not disputing that official definition of a halt decider is self-contradictory?
>

The correct and complete simulation of an input is guaranteed to derive
the actual behavior of this input.

When-so-ever a simulating halt decider (SHD) must abort the simulation
of its input to prevent the infinite execution of this input is merely
another way of saying the the correct and complete simulation of the
input by this SHD would never stop running.

When computer science textbooks say that the behavior that a halt
decider must report on is the behavior of the direct execution of the
machine represented by this input and this behavior is not the same as
the correct and complete simulation of this input then the computer
science textbooks are wrong because they reject the definition of a UTM.
(simulator).

> It's not immediately obvious, but it can be proved that the definition is self-contradictory. You're not disputing that proof?

--
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 9/3/22 8:49 AM, olcott wrote:
> On 9/3/2022 5:32 AM, Richard Damon wrote:
>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com
>>> wrote:
>>>> You just don't understand how logic works.
>>> People in glass houses shouldn’t throw rocks.
>>>
>>> The “law” of excluded middle in Classical logic (P v not P) is the
>>> exact same thing as a decision problem!
>>>
>>> Unless you are in the possession of a proof showing us exactly which
>>> one holds you are, in fact talking about possibilities, not actualities.
>>>
>>> You are talking about an Either monad - yet another (unspecified!)
>>> computation.
>>
>> You are worse the Olcott. He at least beleives the crap he talks
>> about, I'm not so sure you do.
>>
>> If you think he is actually using logic, you have just condemned your
>> ideas to to trash pile.
>
> Paul N believes that two contradictory statements can both be true.
>

So do you, You think that P(P) can Halt but H(P,P) can correctly return
0 when that is DEFINED to mean that P(P) is non-Halting.

FAIL.

On 9/3/2022 8:01 AM, Richard Damon wrote:
> On 9/3/22 7:42 AM, Skep Dick wrote:
>> On Saturday, 3 September 2022 at 12:32:13 UTC+2, richar...@gmail.com
>> wrote:
>>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com
>>>> wrote:
>>>>> You just don't understand how logic works.
>>>> People in glass houses shouldn’t throw rocks.
>>>>
>>>> The “law” of excluded middle in Classical logic (P v not P) is the
>>>> exact same thing as a decision problem!
>>>>
>>>> Unless you are in the possession of a proof showing us exactly which
>>>> one holds you are, in fact talking about possibilities, not
>>>> actualities.
>>>>
>>>> You are talking about an Either monad - yet another (unspecified!)
>>>> computation.
>>> You are worse the Olcott. He at least beleives the crap he talks about,
>>> I'm not so sure you do.
>>>
>>> If you think he is actually using logic, you have just condemned your
>>> ideas to to trash pile.
>>
>>  From where I am looking you seem to think that logic is a monolith.
>>
>> Perhaps that is where all of this confusion comes from? You only know
>> one logic.
>
> I suppose it depends on what you mean by that. "Logic" has few basic
> universal properties, to which we add Logic Model operations relating to
> our Model of Logic, and then we add the Axiom based on the Field we are
> working in.
>
> Note, once you define the Field of Operation that you working in, you
> have chosen your Axioms and Logic Model.
>
> Sometimes in a Application Field we can be investigating if alternate
> Models might be useful to see if other approaches might be useful, but
> any given statement will be attached to a particular Model (and we might
> be comparing the results of two similar statements in different Models).
>
> Trying to talk about the Logic of a Field without defining your Model is
> just worthless, as nothing has meaning.

*THIS IS THE LOGIC THAT CORRECT REASONING IS BASED ON*
The body of analytical knowledge is an interlocking set of mutually
self-defining semantic tautologies that takes this form:
https://en.wikipedia.org/wiki/Ontology_(information_science)

--
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 9/3/22 8:52 AM, olcott wrote:
> On 9/3/2022 6:42 AM, Skep Dick wrote:
>> On Saturday, 3 September 2022 at 12:32:13 UTC+2, richar...@gmail.com
>> wrote:
>>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com
>>>> wrote:
>>>>> You just don't understand how logic works.
>>>> People in glass houses shouldn’t throw rocks.
>>>>
>>>> The “law” of excluded middle in Classical logic (P v not P) is the
>>>> exact same thing as a decision problem!
>>>>
>>>> Unless you are in the possession of a proof showing us exactly which
>>>> one holds you are, in fact talking about possibilities, not
>>>> actualities.
>>>>
>>>> You are talking about an Either monad - yet another (unspecified!)
>>>> computation.
>>> You are worse the Olcott. He at least beleives the crap he talks about,
>>> I'm not so sure you do.
>>>
>>> If you think he is actually using logic, you have just condemned your
>>> ideas to to trash pile.
>>
>>  From where I am looking you seem to think that logic is a monolith.
>>
>> Perhaps that is where all of this confusion comes from? You only know
>> one logic.
>
> Correct reasoning requires applying *ONLY* truth preserving operations
> to a set of premises, making the conclusion a necessary consequence of
> the truth of the premises. The principle of explosion breaks that.
>

Do you understand that the "Principle of Explosion" comes about via a
Proof and not an assumption or Axiom?

The only way to avoid the principle of explosion is to limit what your
logic system can express.

You haven't shown the ability to do that sort of logic.

Go ahead, try to define FORMALLY how you logic system is supposed to
work that avoids the principle of explosion.

On 9/3/22 8:48 AM, olcott wrote:
> On 9/3/2022 5:22 AM, Richard Damon wrote:
>> On 9/2/22 10:49 PM, olcott wrote:
>>> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>>>
>>>> On 9/2/22 10:17 PM, olcott wrote:
>>>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop without being aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition of H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not otherwise ever stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> real code on real machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> empirical testing is 100% reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl Test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't designed to the requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keeps running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software engineering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is going to buy that bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply commenting out the line of code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does the abort prevents the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation from ever stopping that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not stop without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you also edited the program under
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test when you did that, you invalidated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't know
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with those
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with correct complete certainty that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> when commenting out the code the does the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort causes the the simulation to never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop that it is only the abort that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree with me and disagree with your weasel
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> word double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the decider, so editing the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>> changes the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is going to
>>>>>>>>>>>>>>>>>>>>>>>>>>> know that we can test that X causes Y by
>>>>>>>>>>>>>>>>>>>>>>>>>>> removing only X and Y stops happening.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the line
>>>>>>>>>>>>>>>>>>>>>>>>> of code that does the abort is commented out
>>>>>>>>>>>>>>>>>>>>>>>>> and this results in the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) never stopping that this does
>>>>>>>>>>>>>>>>>>>>>>>>> not mean that that it is only the abort that
>>>>>>>>>>>>>>>>>>>>>>>>> causes the simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus your
>>>>>>>>>>>>>>>>>>>>>>>> experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that H(P,P)
>>>>>>>>>>>>>>>>>>>>>>> stops running when H is allowed to abort its
>>>>>>>>>>>>>>>>>>>>>>> simulation of P
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its simulation
>>>>>>>>>>>>>>>>>>>>>> of P (no "allowed" in there, it HAS to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation or it isn't the H you have defined)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that H(P,P)
>>>>>>>>>>>>>>>>>>>>>>> never stops running when H is *NOT* allowed to
>>>>>>>>>>>>>>>>>>>>>>> abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that has
>>>>>>>>>>>>>>>>>>>>>> been defined.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code in
>>>>>>>>>>>>>>>>>>>>> a function the compiler absolutely will not change
>>>>>>>>>>>>>>>>>>>>> the name of this function and you know this so why
>>>>>>>>>>>>>>>>>>>>> lie?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't
>>>>>>>>>>>>>>>>>>>> change the behavior of the function?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then
>>>>>>>>>>>>>>>>>>> this transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the
>>>>>>>>>>>>>>>>>> simulator, so you changed P which isn't allowed
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running
>>>>>>>>>>>>>>>>>>> that conclusively proves that a pure simulation of
>>>>>>>>>>>>>>>>>>> the input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Every competent software engineer knows that my proof
>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have checked with a couple of very competent software
>>>>>>>>>>>>>>>> engineers I know, and none of them agree with you, so
>>>>>>>>>>>>>>>> you claim is proven false by example. You are making the
>>>>>>>>>>>>>>>> fallacy of Ad Populum without even having the populum.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That you play silly games with naming conventions is
>>>>>>>>>>>>>>>>> just like Zeno's paradox that "proves" it is impossible
>>>>>>>>>>>>>>>>> to cross the room to get to the other side.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>>>> conventions" just proves you don't understand what you
>>>>>>>>>>>>>>>> are talking about.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Zeno mathematically proved that two items cannot possibly
>>>>>>>>>>>>>>> touch thus when two items touch the proof is refuted.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, Zeno made the error that an infintly long sum might
>>>>>>>>>>>>>> sum to a finite value.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When we make one single change to H, removing its ability
>>>>>>>>>>>>>>> to abort the simulation of its input then this transforms
>>>>>>>>>>>>>>> the original H into a pure simulator.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when you
>>>>>>>>>>>>>> processs the MODIFIED P that you get from that change you
>>>>>>>>>>>>>> haven't proven anything about the original
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>>> conclusively proves that a pure simulation of the input
>>>>>>>>>>>>>>> to H(P,P) never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> No, because you CAN'T run H and have it never stop
>>>>>>>>>>>>>> running, becaue you have DEFINED (by publishing the code
>>>>>>>>>>>>>> for the H you claim is correct).
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>>>> H(P,P) ever stops running is that H aborts the simulation
>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>
>>>>>>>>>>>> Sort of.
>>>>>>>>>>> A simulating halt decider is required to correctly predict
>>>>>>>>>>> whether or not the hypothetical case of its correct and
>>>>>>>>>>> complete simulation of its input would reach the final state
>>>>>>>>>>> of this input.
>>>>>>>>>>
>>>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so you
>>>>>>>>>> fail
>>>>>>>>>>
>>>>>>>>>> A Halt Decider is required to decide on the ACTUAL BEHAVIOR of
>>>>>>>>>> the ACTUAL MACHINE that the input represents.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>>>> over-ruled and superseded by the behavior of the correct and
>>>>>>>>> complete simulation of this input at the same point in the
>>>>>>>>> execution trace as H.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG.
>>>>>>>>
>>>>>>>>> In other words: Does H(P,P) have to abort its simulation of its
>>>>>>>>> input to prevent the infinite execution of this input?
>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG
>>>>>>>>>
>>>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>
>>>>>>>>> Means that this correctly simulated input cannot reach its own
>>>>>>>>> final state, thus is non-halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> WRONG.
>>>>>>>>
>>>>>>>> If you won't go by the oficial definitions, your H just isn't a
>>>>>>>> Halt Decider.
>>>>>>>>
>>>>>>>
>>>>>>> If the official definitions are self-contradictory then at least
>>>>>>> one of them must be rejected as incorrect.
>>>>>>
>>>>>> And what is contradictory about it?
>>>>>>
>>>>>> A given Turing Machine M applied to an input d will either Halt or
>>>>>> Not.
>>>>>>
>>>>>> THe Halt Decider, when given a
>>>>>>
>>>>>>
>>>>>>>
>>>>>>>> PERIOD.
>>>>>>>>
>>>>>>>> Acting like a two year old won't change that.
>>>>>>>>
>>>>>>>> You won't name a specific thing that I say that is wrong, just
>>>>>>>> that we need you use your definitions that don't match the
>>>>>>>> actual ones.
>>>>>>>>
>>>>>>>> That shows you are just stupid and ignorant.
>>>>>>>>
>>>>>>>> YOU FAIL.
>>>>>>>
>>>>>>> That H(P,P) must abort its simulation of its input means that a
>>>>>>> correct and complete simulation of this input by H would never
>>>>>>> stop running.
>>>>>>
>>>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>>>
>>>>> A correct halt deciding criteria for every halt decider is the
>>>>> correct prediction that the correct and complete simulation of its
>>>>> input would never reach the final state of this simulated input.
>>>>
>>>> No, it is that the actual machine will halt or not.
>>>
>>> Unless you reject the notion of a UTM what I said is true.
>>> Do you reject the notion of a UTM?
>>>
>>
>> Nope, you just don't eem to know what a UTM actually is.
>>
>
> The behavior demonstrated by the correct and complete simulation of a
> machine description is the actual behavior specified by this machine
> description.
>
>

On 9/3/2022 8:06 AM, Richard Damon wrote:
> On 9/3/22 8:49 AM, olcott wrote:
>> On 9/3/2022 5:32 AM, Richard Damon wrote:
>>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2, richar...@gmail.com
>>>> wrote:
>>>>> You just don't understand how logic works.
>>>> People in glass houses shouldn’t throw rocks.
>>>>
>>>> The “law” of excluded middle in Classical logic (P v not P) is the
>>>> exact same thing as a decision problem!
>>>>
>>>> Unless you are in the possession of a proof showing us exactly which
>>>> one holds you are, in fact talking about possibilities, not
>>>> actualities.
>>>>
>>>> You are talking about an Either monad - yet another (unspecified!)
>>>> computation.
>>>
>>> You are worse the Olcott. He at least beleives the crap he talks
>>> about, I'm not so sure you do.
>>>
>>> If you think he is actually using logic, you have just condemned your
>>> ideas to to trash pile.
>>
>> Paul N believes that two contradictory statements can both be true.
>>
>
> So do you, You think that P(P) can Halt but H(P,P) can correctly return
> 0 when that is DEFINED to mean that P(P) is non-Halting.
>
> FAIL.

(a) P(P) depends in the return value from H for its behavior.

(b) The correctly simulated input to H(P,P) cannot depend on any return
value of H because all of these return values from H are unreachable
code for all of these simulated inputs.

Therefore (a) and (b) are not the same sequence of instructions thus not
having the same behavior.

--
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 9/3/2022 8:09 AM, Richard Damon wrote:
> On 9/3/22 8:48 AM, olcott wrote:
>> On 9/3/2022 5:22 AM, Richard Damon wrote:
>>> On 9/2/22 10:49 PM, olcott wrote:
>>>> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/2/22 10:17 PM, olcott wrote:
>>>>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to H(P,P) is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input this simulation would
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop without being aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not otherwise ever stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test" you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> real code on real machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> empirical testing is 100% reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl Test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't designed to the requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keeps running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software engineering
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is going to buy that bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply commenting out the line of code
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that does the abort prevents the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation from ever stopping that the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation does not stop without the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you also edited the program under
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test when you did that, you invalidated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with those
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with correct complete certainty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that when commenting out the code the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does the abort causes the the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to never stop that it is only the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree with me and disagree with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel word double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the decider, so editing the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> changes the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is going
>>>>>>>>>>>>>>>>>>>>>>>>>>>> to know that we can test that X causes Y by
>>>>>>>>>>>>>>>>>>>>>>>>>>>> removing only X and Y stops happening.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the line
>>>>>>>>>>>>>>>>>>>>>>>>>> of code that does the abort is commented out
>>>>>>>>>>>>>>>>>>>>>>>>>> and this results in the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) never stopping that this does
>>>>>>>>>>>>>>>>>>>>>>>>>> not mean that that it is only the abort that
>>>>>>>>>>>>>>>>>>>>>>>>>> causes the simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus
>>>>>>>>>>>>>>>>>>>>>>>>> your experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) stops running when H is allowed to abort
>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its
>>>>>>>>>>>>>>>>>>>>>>> simulation of P (no "allowed" in there, it HAS to
>>>>>>>>>>>>>>>>>>>>>>> abort its simulation or it isn't the H you have
>>>>>>>>>>>>>>>>>>>>>>> defined)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never stops running when H is *NOT*
>>>>>>>>>>>>>>>>>>>>>>>> allowed to abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that has
>>>>>>>>>>>>>>>>>>>>>>> been defined.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code in
>>>>>>>>>>>>>>>>>>>>>> a function the compiler absolutely will not change
>>>>>>>>>>>>>>>>>>>>>> the name of this function and you know this so why
>>>>>>>>>>>>>>>>>>>>>> lie?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't
>>>>>>>>>>>>>>>>>>>>> change the behavior of the function?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then
>>>>>>>>>>>>>>>>>>>> this transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the
>>>>>>>>>>>>>>>>>>> simulator, so you changed P which isn't allowed
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running
>>>>>>>>>>>>>>>>>>>> that conclusively proves that a pure simulation of
>>>>>>>>>>>>>>>>>>>> the input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Every competent software engineer knows that my proof
>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I have checked with a couple of very competent software
>>>>>>>>>>>>>>>>> engineers I know, and none of them agree with you, so
>>>>>>>>>>>>>>>>> you claim is proven false by example. You are making
>>>>>>>>>>>>>>>>> the fallacy of Ad Populum without even having the populum.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That you play silly games with naming conventions is
>>>>>>>>>>>>>>>>>> just like Zeno's paradox that "proves" it is
>>>>>>>>>>>>>>>>>> impossible to cross the room to get to the other side.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>>>>> conventions" just proves you don't understand what you
>>>>>>>>>>>>>>>>> are talking about.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Zeno mathematically proved that two items cannot
>>>>>>>>>>>>>>>> possibly touch thus when two items touch the proof is
>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, Zeno made the error that an infintly long sum might
>>>>>>>>>>>>>>> sum to a finite value.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>> ability to abort the simulation of its input then this
>>>>>>>>>>>>>>>> transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when
>>>>>>>>>>>>>>> you processs the MODIFIED P that you get from that change
>>>>>>>>>>>>>>> you haven't proven anything about the original
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>>>> conclusively proves that a pure simulation of the input
>>>>>>>>>>>>>>>> to H(P,P) never stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No, because you CAN'T run H and have it never stop
>>>>>>>>>>>>>>> running, becaue you have DEFINED (by publishing the code
>>>>>>>>>>>>>>> for the H you claim is correct).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>>>>> H(P,P) ever stops running is that H aborts the simulation
>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Sort of.
>>>>>>>>>>>> A simulating halt decider is required to correctly predict
>>>>>>>>>>>> whether or not the hypothetical case of its correct and
>>>>>>>>>>>> complete simulation of its input would reach the final state
>>>>>>>>>>>> of this input.
>>>>>>>>>>>
>>>>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so you
>>>>>>>>>>> fail
>>>>>>>>>>>
>>>>>>>>>>> A Halt Decider is required to decide on the ACTUAL BEHAVIOR
>>>>>>>>>>> of the ACTUAL MACHINE that the input represents.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>>>>> over-ruled and superseded by the behavior of the correct and
>>>>>>>>>> complete simulation of this input at the same point in the
>>>>>>>>>> execution trace as H.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>>>
>>>>>>>>>> In other words: Does H(P,P) have to abort its simulation of
>>>>>>>>>> its input to prevent the infinite execution of this input?
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG
>>>>>>>>>>
>>>>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>
>>>>>>>>>> Means that this correctly simulated input cannot reach its own
>>>>>>>>>> final state, thus is non-halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> WRONG.
>>>>>>>>>
>>>>>>>>> If you won't go by the oficial definitions, your H just isn't a
>>>>>>>>> Halt Decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> If the official definitions are self-contradictory then at least
>>>>>>>> one of them must be rejected as incorrect.
>>>>>>>
>>>>>>> And what is contradictory about it?
>>>>>>>
>>>>>>> A given Turing Machine M applied to an input d will either Halt
>>>>>>> or Not.
>>>>>>>
>>>>>>> THe Halt Decider, when given a
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>>> PERIOD.
>>>>>>>>>
>>>>>>>>> Acting like a two year old won't change that.
>>>>>>>>>
>>>>>>>>> You won't name a specific thing that I say that is wrong, just
>>>>>>>>> that we need you use your definitions that don't match the
>>>>>>>>> actual ones.
>>>>>>>>>
>>>>>>>>> That shows you are just stupid and ignorant.
>>>>>>>>>
>>>>>>>>> YOU FAIL.
>>>>>>>>
>>>>>>>> That H(P,P) must abort its simulation of its input means that a
>>>>>>>> correct and complete simulation of this input by H would never
>>>>>>>> stop running.
>>>>>>>
>>>>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>>>>
>>>>>> A correct halt deciding criteria for every halt decider is the
>>>>>> correct prediction that the correct and complete simulation of its
>>>>>> input would never reach the final state of this simulated input.
>>>>>
>>>>> No, it is that the actual machine will halt or not.
>>>>
>>>> Unless you reject the notion of a UTM what I said is true.
>>>> Do you reject the notion of a UTM?
>>>>
>>>
>>> Nope, you just don't eem to know what a UTM actually is.
>>>
>>
>> The behavior demonstrated by the correct and complete simulation of a
>> machine description is the actual behavior specified by this machine
>> description.
>>
>>
>
> Right, and UTM(P,P) Halts if H(P,P) returns 0, so that answer HAS to be
> wrong.
>
> Your attempt to CHANGE H to show that changes P, so you aren't
> simulating the actual input to the original H.
>
> You FAIL, you prove yourself to be an idiot.

On 9/3/22 9:16 AM, olcott wrote:
> On 9/3/2022 8:09 AM, Richard Damon wrote:
>> On 9/3/22 8:48 AM, olcott wrote:
>>> On 9/3/2022 5:22 AM, Richard Damon wrote:
>>>> On 9/2/22 10:49 PM, olcott wrote:
>>>>> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/2/22 10:17 PM, olcott wrote:
>>>>>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>>>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would stop without being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not otherwise ever stop running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test" you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with real code on real machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> empirical testing is 100% reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl Test"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> isn't designed to the requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keeps running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering is going to buy that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that if
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simply commenting out the line of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code that does the abort prevents the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation from ever stopping that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation does not stop without
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you also edited the program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> under test when you did that, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invalidated the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> those weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with correct complete certainty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that when commenting out the code the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does the abort causes the the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to never stop that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only the abort that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree with me and disagree with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel word double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the decider, so editing the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> changes the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is going
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to know that we can test that X causes Y by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> removing only X and Y stops happening.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the line
>>>>>>>>>>>>>>>>>>>>>>>>>>> of code that does the abort is commented out
>>>>>>>>>>>>>>>>>>>>>>>>>>> and this results in the correctly simulated
>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) never stopping that this does
>>>>>>>>>>>>>>>>>>>>>>>>>>> not mean that that it is only the abort that
>>>>>>>>>>>>>>>>>>>>>>>>>>> causes the simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus
>>>>>>>>>>>>>>>>>>>>>>>>>> your experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) stops running when H is allowed to abort
>>>>>>>>>>>>>>>>>>>>>>>>> its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its
>>>>>>>>>>>>>>>>>>>>>>>> simulation of P (no "allowed" in there, it HAS
>>>>>>>>>>>>>>>>>>>>>>>> to abort its simulation or it isn't the H you
>>>>>>>>>>>>>>>>>>>>>>>> have defined)
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never stops running when H is *NOT*
>>>>>>>>>>>>>>>>>>>>>>>>> allowed to abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that
>>>>>>>>>>>>>>>>>>>>>>>> has been defined.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code
>>>>>>>>>>>>>>>>>>>>>>> in a function the compiler absolutely will not
>>>>>>>>>>>>>>>>>>>>>>> change the name of this function and you know
>>>>>>>>>>>>>>>>>>>>>>> this so why lie?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't
>>>>>>>>>>>>>>>>>>>>>> change the behavior of the function?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then
>>>>>>>>>>>>>>>>>>>>> this transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the
>>>>>>>>>>>>>>>>>>>> simulator, so you changed P which isn't allowed
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running
>>>>>>>>>>>>>>>>>>>>> that conclusively proves that a pure simulation of
>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Every competent software engineer knows that my proof
>>>>>>>>>>>>>>>>>>> is correct.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I have checked with a couple of very competent
>>>>>>>>>>>>>>>>>> software engineers I know, and none of them agree with
>>>>>>>>>>>>>>>>>> you, so you claim is proven false by example. You are
>>>>>>>>>>>>>>>>>> making the fallacy of Ad Populum without even having
>>>>>>>>>>>>>>>>>> the populum.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That you play silly games with naming conventions is
>>>>>>>>>>>>>>>>>>> just like Zeno's paradox that "proves" it is
>>>>>>>>>>>>>>>>>>> impossible to cross the room to get to the other side.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>>>>>> conventions" just proves you don't understand what you
>>>>>>>>>>>>>>>>>> are talking about.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Zeno mathematically proved that two items cannot
>>>>>>>>>>>>>>>>> possibly touch thus when two items touch the proof is
>>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, Zeno made the error that an infintly long sum might
>>>>>>>>>>>>>>>> sum to a finite value.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then this
>>>>>>>>>>>>>>>>> transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when
>>>>>>>>>>>>>>>> you processs the MODIFIED P that you get from that
>>>>>>>>>>>>>>>> change you haven't proven anything about the original
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>>>>> conclusively proves that a pure simulation of the input
>>>>>>>>>>>>>>>>> to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> No, because you CAN'T run H and have it never stop
>>>>>>>>>>>>>>>> running, becaue you have DEFINED (by publishing the code
>>>>>>>>>>>>>>>> for the H you claim is correct).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>>>>>> H(P,P) ever stops running is that H aborts the simulation
>>>>>>>>>>>>>>> of its input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Sort of.
>>>>>>>>>>>>> A simulating halt decider is required to correctly predict
>>>>>>>>>>>>> whether or not the hypothetical case of its correct and
>>>>>>>>>>>>> complete simulation of its input would reach the final
>>>>>>>>>>>>> state of this input.
>>>>>>>>>>>>
>>>>>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so
>>>>>>>>>>>> you fail
>>>>>>>>>>>>
>>>>>>>>>>>> A Halt Decider is required to decide on the ACTUAL BEHAVIOR
>>>>>>>>>>>> of the ACTUAL MACHINE that the input represents.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>>>>>> over-ruled and superseded by the behavior of the correct and
>>>>>>>>>>> complete simulation of this input at the same point in the
>>>>>>>>>>> execution trace as H.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WRONG.
>>>>>>>>>>
>>>>>>>>>>> In other words: Does H(P,P) have to abort its simulation of
>>>>>>>>>>> its input to prevent the infinite execution of this input?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WRONG
>>>>>>>>>>>
>>>>>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>> ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>
>>>>>>>>>>> Means that this correctly simulated input cannot reach its
>>>>>>>>>>> own final state, thus is non-halting.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WRONG.
>>>>>>>>>>
>>>>>>>>>> If you won't go by the oficial definitions, your H just isn't
>>>>>>>>>> a Halt Decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> If the official definitions are self-contradictory then at
>>>>>>>>> least one of them must be rejected as incorrect.
>>>>>>>>
>>>>>>>> And what is contradictory about it?
>>>>>>>>
>>>>>>>> A given Turing Machine M applied to an input d will either Halt
>>>>>>>> or Not.
>>>>>>>>
>>>>>>>> THe Halt Decider, when given a
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>>> PERIOD.
>>>>>>>>>>
>>>>>>>>>> Acting like a two year old won't change that.
>>>>>>>>>>
>>>>>>>>>> You won't name a specific thing that I say that is wrong, just
>>>>>>>>>> that we need you use your definitions that don't match the
>>>>>>>>>> actual ones.
>>>>>>>>>>
>>>>>>>>>> That shows you are just stupid and ignorant.
>>>>>>>>>>
>>>>>>>>>> YOU FAIL.
>>>>>>>>>
>>>>>>>>> That H(P,P) must abort its simulation of its input means that a
>>>>>>>>> correct and complete simulation of this input by H would never
>>>>>>>>> stop running.
>>>>>>>>
>>>>>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>>>>>
>>>>>>> A correct halt deciding criteria for every halt decider is the
>>>>>>> correct prediction that the correct and complete simulation of
>>>>>>> its input would never reach the final state of this simulated input.
>>>>>>
>>>>>> No, it is that the actual machine will halt or not.
>>>>>
>>>>> Unless you reject the notion of a UTM what I said is true.
>>>>> Do you reject the notion of a UTM?
>>>>>
>>>>
>>>> Nope, you just don't eem to know what a UTM actually is.
>>>>
>>>
>>> The behavior demonstrated by the correct and complete simulation of a
>>> machine description is the actual behavior specified by this machine
>>> description.
>>>
>>>
>>
>> Right, and UTM(P,P) Halts if H(P,P) returns 0, so that answer HAS to
>> be wrong.
>>
>> Your attempt to CHANGE H to show that changes P, so you aren't
>> simulating the actual input to the original H.
>>
>> You FAIL, you prove yourself to be an idiot.
>
> (a) P(P) depends in the return value from H for its behavior.

On 9/3/22 9:07 AM, olcott wrote:
> On 9/3/2022 8:01 AM, Richard Damon wrote:
>> On 9/3/22 7:42 AM, Skep Dick wrote:
>>> On Saturday, 3 September 2022 at 12:32:13 UTC+2, richar...@gmail.com
>>> wrote:
>>>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2,
>>>>> richar...@gmail.com wrote:
>>>>>> You just don't understand how logic works.
>>>>> People in glass houses shouldn’t throw rocks.
>>>>>
>>>>> The “law” of excluded middle in Classical logic (P v not P) is the
>>>>> exact same thing as a decision problem!
>>>>>
>>>>> Unless you are in the possession of a proof showing us exactly
>>>>> which one holds you are, in fact talking about possibilities, not
>>>>> actualities.
>>>>>
>>>>> You are talking about an Either monad - yet another (unspecified!)
>>>>> computation.
>>>> You are worse the Olcott. He at least beleives the crap he talks about,
>>>> I'm not so sure you do.
>>>>
>>>> If you think he is actually using logic, you have just condemned your
>>>> ideas to to trash pile.
>>>
>>>  From where I am looking you seem to think that logic is a monolith.
>>>
>>> Perhaps that is where all of this confusion comes from? You only know
>>> one logic.
>>
>> I suppose it depends on what you mean by that. "Logic" has few basic
>> universal properties, to which we add Logic Model operations relating
>> to our Model of Logic, and then we add the Axiom based on the Field we
>> are working in.
>>
>> Note, once you define the Field of Operation that you working in, you
>> have chosen your Axioms and Logic Model.
>>
>> Sometimes in a Application Field we can be investigating if alternate
>> Models might be useful to see if other approaches might be useful, but
>> any given statement will be attached to a particular Model (and we
>> might be comparing the results of two similar statements in different
>> Models).
>>
>> Trying to talk about the Logic of a Field without defining your Model
>> is just worthless, as nothing has meaning.
>
> *THIS IS THE LOGIC THAT CORRECT REASONING IS BASED ON*
> The body of analytical knowledge is an interlocking set of mutually
> self-defining semantic tautologies that takes this form:
> https://en.wikipedia.org/wiki/Ontology_(information_science)
>

Right, so why aren't you using the definition that Computation Theory is
based on?

You can't be working in a field if you don't use the defitions that are
part of that field.

On 9/3/22 9:15 AM, olcott wrote:
> On 9/3/2022 8:06 AM, Richard Damon wrote:
>> On 9/3/22 8:49 AM, olcott wrote:
>>> On 9/3/2022 5:32 AM, Richard Damon wrote:
>>>> On 9/3/22 12:35 AM, Skep Dick wrote:
>>>>> On Saturday, 3 September 2022 at 04:40:41 UTC+2,
>>>>> richar...@gmail.com wrote:
>>>>>> You just don't understand how logic works.
>>>>> People in glass houses shouldn’t throw rocks.
>>>>>
>>>>> The “law” of excluded middle in Classical logic (P v not P) is the
>>>>> exact same thing as a decision problem!
>>>>>
>>>>> Unless you are in the possession of a proof showing us exactly
>>>>> which one holds you are, in fact talking about possibilities, not
>>>>> actualities.
>>>>>
>>>>> You are talking about an Either monad - yet another (unspecified!)
>>>>> computation.
>>>>
>>>> You are worse the Olcott. He at least beleives the crap he talks
>>>> about, I'm not so sure you do.
>>>>
>>>> If you think he is actually using logic, you have just condemned
>>>> your ideas to to trash pile.
>>>
>>> Paul N believes that two contradictory statements can both be true.
>>>
>>
>> So do you, You think that P(P) can Halt but H(P,P) can correctly
>> return 0 when that is DEFINED to mean that P(P) is non-Halting.
>>
>> FAIL.
>
> (a) P(P) depends in the return value from H for its behavior.
>
> (b) The correctly simulated input to H(P,P) cannot depend on any return
> value of H because all of these return values from H are unreachable
> code for all of these simulated inputs.

Wrong. The CORRECT answer DOES depend on that behavior, since from (a)
that does affect the behavior that H needs to be deciding on.

The answer that H CAN give can't, but that is what makes H give the
wrong answer.

This is the difference between CAN and MUST/Should.

Note, the code isn't unreachable in a correct and complete simulation of
the input, it is only unreachable by H.

Note, Mr Flibble has shown an alternate way of building H where it can
see that results of that code.

>
> Therefore (a) and (b) are not the same sequence of instructions thus not
> having the same behavior.
>

WRONG. You just show you don't understand the meaning of "Correct".

(a) and (b) are EXACTLY the same sequence of instructions (when
completely simulated) or you are just lying about what you are doing.

On 9/3/22 9:03 AM, olcott wrote:
> On 9/3/2022 7:50 AM, Paul N wrote:
>> On Saturday, September 3, 2022 at 1:43:43 PM UTC+1, olcott wrote:
>>> On 9/3/2022 7:00 AM, Paul N wrote:
>>>> On Saturday, September 3, 2022 at 2:54:54 AM UTC+1, olcott wrote:
>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>> If you won't go by the oficial definitions, your H just isn't a Halt
>>>>>> Decider.
>>>>>>
>>>>> If the official definitions are self-contradictory then at least
>>>>> one of
>>>>> them must be rejected as incorrect.
>>>>
>>>> No, you are wrong here. The official definition of a halt decider is
>>>> self-contradictory, in that it is impossible to build anything which
>>>> meets the definition. This has been proved.
>>> That is not the way truth works mate. If the official definitions are
>>> self-contradictory then I have also had new insight on that another
>>> aspect of computer science is incorrect.
>>
>> So you are not disputing that official definition of a halt decider is
>> self-contradictory?
>>
>
> The correct and complete simulation of an input is guaranteed to derive
> the actual behavior of this input.
>
> When-so-ever a simulating halt decider (SHD) must abort the simulation
> of its input to prevent the infinite execution of this input is merely
> another way of saying the the correct and complete simulation of the
> input by this SHD would never stop running.
>
> When computer science textbooks say that the behavior that a halt
> decider must report on is the behavior of the direct execution of the
> machine represented by this input and this behavior is not the same as
> the correct and complete simulation of this input then the computer
> science textbooks are wrong because they reject the definition of a UTM.
> (simulator).

But the correct and complete simulation DOES match the behavior of the
direct execution.

You just never actually look at the correct and complete simulation of
the acutal input to the original call the H(P,P).

>
>> It's not immediately obvious, but it can be proved that the definition
>> is self-contradictory. You're not disputing that proof?
>

Since UTM(P,P), the direct and complete simulation of the input to
H(P,P), where H(P,P) returns 0, does Halt, so there is no contradiction.

Yor problem is you look at UTM(Pn,Pn) instead of UTM(P,P) so you get the
wrong answer. (This is where Pn is based on Hn the modified version of H
that you make to do the supposed correct and complete simulation).

On 9/3/2022 8:29 AM, Richard Damon wrote:
>
> On 9/3/22 9:16 AM, olcott wrote:
>> On 9/3/2022 8:09 AM, Richard Damon wrote:
>>> On 9/3/22 8:48 AM, olcott wrote:
>>>> On 9/3/2022 5:22 AM, Richard Damon wrote:
>>>>> On 9/2/22 10:49 PM, olcott wrote:
>>>>>> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/2/22 10:17 PM, olcott wrote:
>>>>>>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>>>>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would stop without being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not otherwise ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test" you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with real code on real machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> empirical testing is 100% reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Test" isn't designed to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keeps running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering is going to buy that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if simply commenting out the line of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> code that does the abort prevents
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation from ever stopping
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that the simulation does not stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> without the abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you also edited the program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> under test when you did that, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invalidated the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> those weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know with correct complete certainty
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that when commenting out the code the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does the abort causes the the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to never stop that it is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> only the abort that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree with me and disagree with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel word double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the decider, so editing the decider
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> changes the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is going
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to know that we can test that X causes Y
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> by removing only X and Y stops happening.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> line of code that does the abort is
>>>>>>>>>>>>>>>>>>>>>>>>>>>> commented out and this results in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input to H(P,P) never
>>>>>>>>>>>>>>>>>>>>>>>>>>>> stopping that this does not mean that that
>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is only the abort that causes the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus
>>>>>>>>>>>>>>>>>>>>>>>>>>> your experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) stops running when H is allowed to
>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation of P (no "allowed" in there, it HAS
>>>>>>>>>>>>>>>>>>>>>>>>> to abort its simulation or it isn't the H you
>>>>>>>>>>>>>>>>>>>>>>>>> have defined)
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never stops running when H is *NOT*
>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that
>>>>>>>>>>>>>>>>>>>>>>>>> has been defined.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code
>>>>>>>>>>>>>>>>>>>>>>>> in a function the compiler absolutely will not
>>>>>>>>>>>>>>>>>>>>>>>> change the name of this function and you know
>>>>>>>>>>>>>>>>>>>>>>>> this so why lie?
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't
>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the function?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then
>>>>>>>>>>>>>>>>>>>>>> this transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the
>>>>>>>>>>>>>>>>>>>>> simulator, so you changed P which isn't allowed
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running
>>>>>>>>>>>>>>>>>>>>>> that conclusively proves that a pure simulation of
>>>>>>>>>>>>>>>>>>>>>> the input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Every competent software engineer knows that my
>>>>>>>>>>>>>>>>>>>> proof is correct.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I have checked with a couple of very competent
>>>>>>>>>>>>>>>>>>> software engineers I know, and none of them agree
>>>>>>>>>>>>>>>>>>> with you, so you claim is proven false by example.
>>>>>>>>>>>>>>>>>>> You are making the fallacy of Ad Populum without even
>>>>>>>>>>>>>>>>>>> having the populum.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That you play silly games with naming conventions is
>>>>>>>>>>>>>>>>>>>> just like Zeno's paradox that "proves" it is
>>>>>>>>>>>>>>>>>>>> impossible to cross the room to get to the other side.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>>>>>>> conventions" just proves you don't understand what
>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Zeno mathematically proved that two items cannot
>>>>>>>>>>>>>>>>>> possibly touch thus when two items touch the proof is
>>>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, Zeno made the error that an infintly long sum might
>>>>>>>>>>>>>>>>> sum to a finite value.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then this
>>>>>>>>>>>>>>>>>> transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when
>>>>>>>>>>>>>>>>> you processs the MODIFIED P that you get from that
>>>>>>>>>>>>>>>>> change you haven't proven anything about the original
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running that
>>>>>>>>>>>>>>>>>> conclusively proves that a pure simulation of the
>>>>>>>>>>>>>>>>>> input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, because you CAN'T run H and have it never stop
>>>>>>>>>>>>>>>>> running, becaue you have DEFINED (by publishing the
>>>>>>>>>>>>>>>>> code for the H you claim is correct).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>>>>>>> H(P,P) ever stops running is that H aborts the
>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Sort of.
>>>>>>>>>>>>>> A simulating halt decider is required to correctly predict
>>>>>>>>>>>>>> whether or not the hypothetical case of its correct and
>>>>>>>>>>>>>> complete simulation of its input would reach the final
>>>>>>>>>>>>>> state of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so
>>>>>>>>>>>>> you fail
>>>>>>>>>>>>>
>>>>>>>>>>>>> A Halt Decider is required to decide on the ACTUAL BEHAVIOR
>>>>>>>>>>>>> of the ACTUAL MACHINE that the input represents.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>>>>>>> over-ruled and superseded by the behavior of the correct and
>>>>>>>>>>>> complete simulation of this input at the same point in the
>>>>>>>>>>>> execution trace as H.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WRONG.
>>>>>>>>>>>
>>>>>>>>>>>> In other words: Does H(P,P) have to abort its simulation of
>>>>>>>>>>>> its input to prevent the infinite execution of this input?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WRONG
>>>>>>>>>>>>
>>>>>>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>
>>>>>>>>>>>> Means that this correctly simulated input cannot reach its
>>>>>>>>>>>> own final state, thus is non-halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> WRONG.
>>>>>>>>>>>
>>>>>>>>>>> If you won't go by the oficial definitions, your H just isn't
>>>>>>>>>>> a Halt Decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> If the official definitions are self-contradictory then at
>>>>>>>>>> least one of them must be rejected as incorrect.
>>>>>>>>>
>>>>>>>>> And what is contradictory about it?
>>>>>>>>>
>>>>>>>>> A given Turing Machine M applied to an input d will either Halt
>>>>>>>>> or Not.
>>>>>>>>>
>>>>>>>>> THe Halt Decider, when given a
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> PERIOD.
>>>>>>>>>>>
>>>>>>>>>>> Acting like a two year old won't change that.
>>>>>>>>>>>
>>>>>>>>>>> You won't name a specific thing that I say that is wrong,
>>>>>>>>>>> just that we need you use your definitions that don't match
>>>>>>>>>>> the actual ones.
>>>>>>>>>>>
>>>>>>>>>>> That shows you are just stupid and ignorant.
>>>>>>>>>>>
>>>>>>>>>>> YOU FAIL.
>>>>>>>>>>
>>>>>>>>>> That H(P,P) must abort its simulation of its input means that
>>>>>>>>>> a correct and complete simulation of this input by H would
>>>>>>>>>> never stop running.
>>>>>>>>>
>>>>>>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>>>>>>
>>>>>>>> A correct halt deciding criteria for every halt decider is the
>>>>>>>> correct prediction that the correct and complete simulation of
>>>>>>>> its input would never reach the final state of this simulated
>>>>>>>> input.
>>>>>>>
>>>>>>> No, it is that the actual machine will halt or not.
>>>>>>
>>>>>> Unless you reject the notion of a UTM what I said is true.
>>>>>> Do you reject the notion of a UTM?
>>>>>>
>>>>>
>>>>> Nope, you just don't eem to know what a UTM actually is.
>>>>>
>>>>
>>>> The behavior demonstrated by the correct and complete simulation of
>>>> a machine description is the actual behavior specified by this
>>>> machine description.
>>>>
>>>>
>>>
>>> Right, and UTM(P,P) Halts if H(P,P) returns 0, so that answer HAS to
>>> be wrong.
>>>
>>> Your attempt to CHANGE H to show that changes P, so you aren't
>>> simulating the actual input to the original H.
>>>
>>> You FAIL, you prove yourself to be an idiot.
>>
>> (a) P(P) depends in the return value from H for its behavior.
>
> Right
>
>>
>> (b) The correctly simulated input to H(P,P) cannot depend on any
>> return value of H because all of these return values from H are
>> unreachable code for all of these simulated inputs.
>
> Wrong. The CORRECT answer DOES depend on that behavior,

On 9/3/22 9:41 AM, olcott wrote:
> On 9/3/2022 8:29 AM, Richard Damon wrote:
>>
>> On 9/3/22 9:16 AM, olcott wrote:
>>> On 9/3/2022 8:09 AM, Richard Damon wrote:
>>>> On 9/3/22 8:48 AM, olcott wrote:
>>>>> On 9/3/2022 5:22 AM, Richard Damon wrote:
>>>>>> On 9/2/22 10:49 PM, olcott wrote:
>>>>>>> On 9/2/2022 9:40 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/2/22 10:17 PM, olcott wrote:
>>>>>>>>> On 9/2/2022 9:06 PM, Richard Damon wrote:
>>>>>>>>>> On 9/2/22 9:54 PM, olcott wrote:
>>>>>>>>>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
>>>>>>>>>>>>
>>>>>>>>>>>> On 9/2/22 8:41 PM, olcott wrote:
>>>>>>>>>>>>> On 9/2/2022 6:27 PM, Richard Damon wrote:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 9/2/22 7:11 PM, olcott wrote:
>>>>>>>>>>>>>>> On 9/2/2022 5:41 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/2/22 6:21 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/2/2022 5:05 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 9/2/22 5:56 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/2/2022 4:49 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 9/2/22 5:37 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 4:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 5:07 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:56 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:46 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:38 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 4:31 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 3:08 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:53 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:38 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 3:11 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 1:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 1:57 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/2022 7:19 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/2/22 12:35 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:32 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:26 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:23 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:18 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 10:13 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 11:02 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 9:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 8:18 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/2022 5:52 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 9/1/22 10:37 AM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, The finite string
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to H(P,P) is the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> representation of P(P),
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If this was true then when
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input this simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> would stop without being
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No, because your definition
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of H aborts its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means that empirical testing
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> proves that the simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> does not otherwise ever stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because the "empirical
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> test" you use
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is valid, when we are working
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with real code on real machines
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> empirical testing is 100%
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reliable.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because your "Empericl
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Test" isn't designed to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirements.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The requirements are simply this:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Does the simulated input stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running if not aborted?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Comment out the abort code and it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> keeps running thus: NO
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, you changed the input, thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the test is invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> No one that knows software
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> engineering is going to buy that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> bullshit.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every software engineer knows that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> if simply commenting out the line
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of code that does the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> prevents the simulation from ever
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stopping that the simulation does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not stop without the abort.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, and that shows your ignorance.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Since you also edited the program
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> under test when you did that, you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invalidated the test.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You just are proving that you don't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> know what you are talking about
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are not going to get away with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> those weasel words of double-talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> will know with correct complete
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> certainty that when commenting out
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the code the does the abort causes
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the the simulation to never stop that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is only the abort that stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope. Since that changes the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the input, it is an invalid operation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer will
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> agree with me and disagree with your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> weasel word double talk.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Name ONE.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Make sure the understand that the input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls the decider, so editing the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider changes the input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Every competent software engineer is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> going to know that we can test that X
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> causes Y by removing only X and Y stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> happening.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So, you don't know anyone willing to go on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> record to support you.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Guess that shows how reliable your claim its.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> FAIL.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> So you are claiming that when *only* the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> line of code that does the abort is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> commented out and this results in the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> correctly simulated input to H(P,P) never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stopping that this does not mean that that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> it is only the abort that causes the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation to stop IS NOT PROVEN ???
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> By Changing H, you have changed P, and thus
>>>>>>>>>>>>>>>>>>>>>>>>>>>> your experement" showed the wrong thing,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) stops running when H is allowed to
>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Right.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Because H has been DEFINED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of P (no "allowed" in there, it HAS
>>>>>>>>>>>>>>>>>>>>>>>>>> to abort its simulation or it isn't the H you
>>>>>>>>>>>>>>>>>>>>>>>>>> have defined)
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) I assert that it is a proven fact that
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(P,P) never stops running when H is *NOT*
>>>>>>>>>>>>>>>>>>>>>>>>>>> allowed to abort its simulation of P
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Nope, because then it is no longer the H that
>>>>>>>>>>>>>>>>>>>>>>>>>> has been defined.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Sure it is. When you comment out a line-of-code
>>>>>>>>>>>>>>>>>>>>>>>>> in a function the compiler absolutely will not
>>>>>>>>>>>>>>>>>>>>>>>>> change the name of this function and you know
>>>>>>>>>>>>>>>>>>>>>>>>> this so why lie?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> So you claim commenting out a statement doesn't
>>>>>>>>>>>>>>>>>>>>>>>> change the behavior of the function?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then
>>>>>>>>>>>>>>>>>>>>>>> this transforms the original H into a pure
>>>>>>>>>>>>>>>>>>>>>>> simulator.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, but P is calling the deciderm not the
>>>>>>>>>>>>>>>>>>>>>> simulator, so you changed P which isn't allowed
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running
>>>>>>>>>>>>>>>>>>>>>>> that conclusively proves that a pure simulation
>>>>>>>>>>>>>>>>>>>>>>> of the input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Right, and you just ran H on a DIFERERNT P, so its
>>>>>>>>>>>>>>>>>>>>>> answer is irrelevent to the original question.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Every competent software engineer knows that my
>>>>>>>>>>>>>>>>>>>>> proof is correct.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> FALSE.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Name one.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You are just proven to be a liar.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I have checked with a couple of very competent
>>>>>>>>>>>>>>>>>>>> software engineers I know, and none of them agree
>>>>>>>>>>>>>>>>>>>> with you, so you claim is proven false by example.
>>>>>>>>>>>>>>>>>>>> You are making the fallacy of Ad Populum without
>>>>>>>>>>>>>>>>>>>> even having the populum.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That you play silly games with naming conventions
>>>>>>>>>>>>>>>>>>>>> is just like Zeno's paradox that "proves" it is
>>>>>>>>>>>>>>>>>>>>> impossible to cross the room to get to the other side.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope, that you call then "silly games with naming
>>>>>>>>>>>>>>>>>>>> conventions" just proves you don't understand what
>>>>>>>>>>>>>>>>>>>> you are talking about.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> https://owlcation.com/stem/understanding-and-solving-Zenos-paradox#:~:text=In%20its%20simplest%20form%2C%20Zeno's,before%20reaching%20the%20stationary%20ball.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Red Herring.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Zeno mathematically proved that two items cannot
>>>>>>>>>>>>>>>>>>> possibly touch thus when two items touch the proof is
>>>>>>>>>>>>>>>>>>> refuted.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, Zeno made the error that an infintly long sum
>>>>>>>>>>>>>>>>>> might sum to a finite value.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When we make one single change to H, removing its
>>>>>>>>>>>>>>>>>>> ability to abort the simulation of its input then
>>>>>>>>>>>>>>>>>>> this transforms the original H into a pure simulator.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Right, which is a DIFFERENT computation, and thus when
>>>>>>>>>>>>>>>>>> you processs the MODIFIED P that you get from that
>>>>>>>>>>>>>>>>>> change you haven't proven anything about the original
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Your references to Zeno are just a Red Herring Fallacy.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *THIS IS TRUE ON THE BASIS OF THE MEANING OF ITS WORDS*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Nope. You have wrong meanings to the words.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Now when we run H(P,P) and it never stops running
>>>>>>>>>>>>>>>>>>> that conclusively proves that a pure simulation of
>>>>>>>>>>>>>>>>>>> the input to H(P,P) never stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, because you CAN'T run H and have it never stop
>>>>>>>>>>>>>>>>>> running, becaue you have DEFINED (by publishing the
>>>>>>>>>>>>>>>>>> code for the H you claim is correct).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is an easily verified fact that the only reason that
>>>>>>>>>>>>>>>>> H(P,P) ever stops running is that H aborts the
>>>>>>>>>>>>>>>>> simulation of its input.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Sort of.
>>>>>>>>>>>>>>> A simulating halt decider is required to correctly
>>>>>>>>>>>>>>> predict whether or not the hypothetical case of its
>>>>>>>>>>>>>>> correct and complete simulation of its input would reach
>>>>>>>>>>>>>>> the final state of this input.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The your simulating Halt Decider isn't a Halt Decider, so
>>>>>>>>>>>>>> you fail
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A Halt Decider is required to decide on the ACTUAL
>>>>>>>>>>>>>> BEHAVIOR of the ACTUAL MACHINE that the input represents.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Any misconception of the behavior of the input to H(P,P) is
>>>>>>>>>>>>> over-ruled and superseded by the behavior of the correct
>>>>>>>>>>>>> and complete simulation of this input at the same point in
>>>>>>>>>>>>> the execution trace as H.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>
>>>>>>>>>>>>> In other words: Does H(P,P) have to abort its simulation of
>>>>>>>>>>>>> its input to prevent the infinite execution of this input?
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>> ALWAYS ALWAYS ALWAYS
>>>>>>>>>>>>>
>>>>>>>>>>>>> Means that this correctly simulated input cannot reach its
>>>>>>>>>>>>> own final state, thus is non-halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> WRONG.
>>>>>>>>>>>>
>>>>>>>>>>>> If you won't go by the oficial definitions, your H just
>>>>>>>>>>>> isn't a Halt Decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> If the official definitions are self-contradictory then at
>>>>>>>>>>> least one of them must be rejected as incorrect.
>>>>>>>>>>
>>>>>>>>>> And what is contradictory about it?
>>>>>>>>>>
>>>>>>>>>> A given Turing Machine M applied to an input d will either
>>>>>>>>>> Halt or Not.
>>>>>>>>>>
>>>>>>>>>> THe Halt Decider, when given a
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>> PERIOD.
>>>>>>>>>>>>
>>>>>>>>>>>> Acting like a two year old won't change that.
>>>>>>>>>>>>
>>>>>>>>>>>> You won't name a specific thing that I say that is wrong,
>>>>>>>>>>>> just that we need you use your definitions that don't match
>>>>>>>>>>>> the actual ones.
>>>>>>>>>>>>
>>>>>>>>>>>> That shows you are just stupid and ignorant.
>>>>>>>>>>>>
>>>>>>>>>>>> YOU FAIL.
>>>>>>>>>>>
>>>>>>>>>>> That H(P,P) must abort its simulation of its input means that
>>>>>>>>>>> a correct and complete simulation of this input by H would
>>>>>>>>>>> never stop running.
>>>>>>>>>>
>>>>>>>>>> Nope. Remember "Must" is a bad word, H either DOES or it DOESN'T
>>>>>>>>>
>>>>>>>>> A correct halt deciding criteria for every halt decider is the
>>>>>>>>> correct prediction that the correct and complete simulation of
>>>>>>>>> its input would never reach the final state of this simulated
>>>>>>>>> input.
>>>>>>>>
>>>>>>>> No, it is that the actual machine will halt or not.
>>>>>>>
>>>>>>> Unless you reject the notion of a UTM what I said is true.
>>>>>>> Do you reject the notion of a UTM?
>>>>>>>
>>>>>>
>>>>>> Nope, you just don't eem to know what a UTM actually is.
>>>>>>
>>>>>
>>>>> The behavior demonstrated by the correct and complete simulation of
>>>>> a machine description is the actual behavior specified by this
>>>>> machine description.
>>>>>
>>>>>
>>>>
>>>> Right, and UTM(P,P) Halts if H(P,P) returns 0, so that answer HAS to
>>>> be wrong.
>>>>
>>>> Your attempt to CHANGE H to show that changes P, so you aren't
>>>> simulating the actual input to the original H.
>>>>
>>>> You FAIL, you prove yourself to be an idiot.
>>>
>>> (a) P(P) depends in the return value from H for its behavior.
>>
>> Right
>>
>>>
>>> (b) The correctly simulated input to H(P,P) cannot depend on any
>>> return value of H because all of these return values from H are
>>> unreachable code for all of these simulated inputs.
>>
>> Wrong. The CORRECT answer DOES depend on that behavior,
>
> You just contradicted yourself.
>

On Saturday, September 3, 2022 at 2:03:48 PM UTC+1, olcott wrote:
> On 9/3/2022 7:50 AM, Paul N wrote:
> > On Saturday, September 3, 2022 at 1:43:43 PM UTC+1, olcott wrote:
> >> On 9/3/2022 7:00 AM, Paul N wrote:
> >>> On Saturday, September 3, 2022 at 2:54:54 AM UTC+1, olcott wrote:
> >>>> On 9/2/2022 7:46 PM, Richard Damon wrote:
> >>>>> If you won't go by the oficial definitions, your H just isn't a Halt
> >>>>> Decider.
> >>>>>
> >>>> If the official definitions are self-contradictory then at least one of
> >>>> them must be rejected as incorrect.
> >>>
> >>> No, you are wrong here. The official definition of a halt decider is self-contradictory, in that it is impossible to build anything which meets the definition. This has been proved.
> >> That is not the way truth works mate. If the official definitions are
> >> self-contradictory then I have also had new insight on that another
> >> aspect of computer science is incorrect.
> >
> > So you are not disputing that official definition of a halt decider is self-contradictory?
> >
> The correct and complete simulation of an input is guaranteed to derive
> the actual behavior of this input.
>
> When-so-ever a simulating halt decider (SHD) must abort the simulation
> of its input to prevent the infinite execution of this input is merely
> another way of saying the the correct and complete simulation of the
> input by this SHD would never stop running.
>
> When computer science textbooks say that the behavior that a halt
> decider must report on is the behavior of the direct execution of the
> machine represented by this input and this behavior is not the same as
> the correct and complete simulation of this input then the computer
> science textbooks are wrong because they reject the definition of a UTM.
> (simulator).

I was hoping for more of a yes-or-no type answer.

> > It's not immediately obvious, but it can be proved that the definition is self-contradictory. You're not disputing that proof?