On 9/3/22 2:04 PM, olcott wrote:
> On 9/3/2022 12:44 PM, Richard Damon wrote:
>>
>> On 9/3/22 1:34 PM, olcott wrote:
>>> On 9/3/2022 12:19 PM, Paul N wrote:
>>>> On Saturday, September 3, 2022 at 3:14:51 PM UTC+1, olcott wrote:
>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>> 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.
>>>>>>
>>>>> When I provide a complete explanation of the reasoning behind the
>>>>> answer
>>>>> all those not understanding these things cannot simply baselessly
>>>>> disagree. All disagreement is thus required to have a basis. This way
>>>>> people are not lead astray by a bunch of baseless disagreement,
>>>>> they see
>>>>> that the disagreement has no basis and reject it.
>>>>
>>>> Yes, it is helpful to provide reasoning behind your answers.
>>>>
>>>> However, I can't actually tell from your reasoning what your actual
>>>> answer is. Do you, or do you not, accept that the official
>>>> definition of a halt decider is self-contradictory?
>>>
>>> (a) In the case where the behavior of an input must be aborted to
>>> prevent the infinite simulation of this input this is merely another
>>> way of saying that the correct and complete simulation by H(P,P) of
>>> its input never halts.
>>
>> But we don't know if the input "must be aborted" by your proof.
> Every proof that I provide you find some dishonest dodge for a dishonest
> fake rebuttal.

What "Dishonest Dodge" did I do? Other than pointing out the ACTUAL
DEFINTION of things. Either you don't know the meaning of that word, or
it is YOUR Dishonest Dodge to avoid needing to try to rebut that error I
point out.

>
> The bigger question is when we both know that the input to H(P,P)
> correctly simulated by H never stops unless H aborts its simulation

Nope, You don't understand that ypu keep on conflating two different
Computations. That make you a deceiver, aka a Liar.

>
> WHY THE HELL DO YOU DENY SOMETHING THAT YOU KNOW IS TRUE?
>
>

Because your statement isn't because it is based on the Lie that Pn
based on Hn is the same computation as P based on H.

Yes, you have proved that Pn(Pn) is non-halting, and thus Hn WOULD HAVE
BEEN correct to answer 0 for Hn(Pn,Pn), except that it doesn't answer,
and that H(Pn,Pn) returning 0 is also correct, but not the required
question to be a counter example.

It has been shown that P(P) Halts, and this is even proven by Pn(P,P)
correctly and completely simulating this input and answering 1.

This shows that the CORRECT answer to H(P,P) IS 1, even though it returns 0.

Show the error in that logic.

On 9/3/22 2:13 PM, olcott wrote:
> On 9/3/2022 12:52 PM, Paul N wrote:
>> On Saturday, September 3, 2022 at 6:34:24 PM UTC+1, olcott wrote:
>>> On 9/3/2022 12:19 PM, Paul N wrote:
>>>> On Saturday, September 3, 2022 at 3:14:51 PM UTC+1, olcott wrote:
>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>> 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.
>>>>>>
>>>>> When I provide a complete explanation of the reasoning behind the
>>>>> answer
>>>>> all those not understanding these things cannot simply baselessly
>>>>> disagree. All disagreement is thus required to have a basis. This way
>>>>> people are not lead astray by a bunch of baseless disagreement,
>>>>> they see
>>>>> that the disagreement has no basis and reject it.
>>>>
>>>> Yes, it is helpful to provide reasoning behind your answers.
>>>>
>>>> However, I can't actually tell from your reasoning what your actual
>>>> answer is. Do you, or do you not, accept that the official
>>>> definition of a halt decider is self-contradictory?
>>> (a) In the case where the behavior of an input must be aborted to
>>> prevent the infinite simulation of this input this is merely another way
>>> of saying that the correct and complete simulation by H(P,P) of its
>>> input never halts.
>>>
>>> (b) The definition of a UTM says that the correct and complete
>>> simulation of a machine description derives the actual behavior
>>> specified by this machine description.
>>> (c) A halt decider must compute the mapping from its input finite
>>> strings to an accept or reject state based on the actual behavior
>>> specified by this finite string machine description.
>>>
>>> (a)(b)(c) proves H(P,P)==0 is correct and anything (or anyone) that
>>> disagrees is incorrect.
>>
>> You're actually incapable of saying yes or no?
>
> You are incapable of correctly inferring Yes or No based on what I said
> above?
>
> If I say Yes or No it is possible to baselessly disagree.
> When I provide only the reasoning for Yes or No it is impossible to
> baselessly disagree.
>
> When we ask a Trump supporter to provide any evidence submitted in any
> of Trump's election fraud court cases that proves that election fraud
> occurred they can only STFU because there was no evidence ever submitted
> in any of these cases. Trump's lawyers did not want to go to prison for
> perjury and had no actual evidence to submit.
>

So you won't answer yes or no because if you answer yes then you will
need to obey those definitions, which you don't, or if you answer no you
admit that you aren't and thus prove your answer doesn't matter.

Sounds like YOU are being like those people, not able to provide any
real evidence but just keep claiming that it must be true.

YOU FAIL,

On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com wrote:
> On 9/3/22 1:18 PM, olcott wrote:
> > On 9/3/2022 12:08 PM, Richard Damon wrote:
> >> On 9/3/22 12:56 PM, olcott wrote:
> >>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>
> >>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
> >>>>>>>>>>>>>>> behind the answer all those not understanding these
> >>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
> >>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
> >>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
> >>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
> >>>>>>>>>>>>>>> and reject it.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
> >>>>>>>>>>>>>> starting from ACCEPTED definition.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You just make wild claims based on your own understanding
> >>>>>>>>>>>>>> of the words.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
> >>>>>>>>>>>>>> no one can help you with your logic.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
> >>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
> >>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
> >>>>>>>>>>>>>> basd on the common name with a modifier).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
> >>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
> >>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
> >>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
> >>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
> >>>>>>>>>>>>>> proven what you claim to have proven.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
> >>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
> >>>>>>>>>>>>>>>>>> disputing that proof?
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
> >>>>>>>>>>>>>> using altered definition that you aren't providing.
> >>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
> >>>>>>>>>>>>> incorrect basis.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
> >>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
> >>>>>>>>>>>
> >>>>>>>>>>> When you get a glass of water and dump it on the floor you
> >>>>>>>>>>> cannot truthfully deny that the floor is wet.
> >>>>>>>>>>
> >>>>>>>>>> And I haven't
> >>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> When the correct and complete simulation of the input by
> >>>>>>>>>>> H(P,P) would have different behavior than the direct
> >>>>>>>>>>> execution of P(P) this cannot simply be ignored.
> >>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>
> >>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
> >>>>>>>>>> Halts.
> >>>>>>>>>>
> >>>>>>>>>
> >>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
> >>>>>>>>> running unless H aborts the simulation of this input is merely
> >>>>>>>>> another way of saying that the correct and complete simulation
> >>>>>>>>> of this input by H never halts.
> >>>>>>>>
> >>>>>>>> You have bad logic there.
> >>>>>>>
> >>>>>>> It is a tautology:
> >>>>>>>
> >>>>>>> void Infinite_Loop()
> >>>>>>> {
> >>>>>>> HERE: goto HERE;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>> }
> >>>>>>>
> >>>>>>> _Infinite_Loop()
> >>>>>>> [00001102](01) 55 push ebp
> >>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>> [00001107](01) 5d pop ebp
> >>>>>>> [00001108](01) c3 ret
> >>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>
> >>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
> >>>>>>> would never stop running unless H0 aborts the simulation of this
> >>>>>>> input is merely another way of saying that the correct and
> >>>>>>> complete simulation of this input by H0 never halts.
> >>>>>>>
> >>>>>>
> >>>>>> Strawman.
> >>>>>>
> >>>>>> Fallacy of Proof by Example.
> >>>>>
> >>>>> It is only a fallacy by proof of example when a single example is
> >>>>> not representative of the entire class of all such examples.
> >>>>
> >>>> Which it isn't, so FAIL.
> >>>>
> >>>>>
> >>>>> You are confusing existential quantification with universal
> >>>>> quantification.
> >>>>
> >>>> No you are, since you are claiming the rule works for ALL inputs (or
> >>>> at least P, which isn't the input you showed it worked for).
> >>>>
> >>>>>
> >>>>> ∀ simulating halt decider H
> >>>>> ∀ machine description P
> >>>>
> >>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>
> >>>> You don't seem to know what those words mean.
> >>>>
> >>>>>
> >>>>> The fact that the correct simulation of any input P to any
> >>>>> simulating halt decider (SHD) H would never stop running unless
> >>>>> this simulation was aborted by this SHD is merely another way of
> >>>>> saying that the correct and complete simulation of this input by
> >>>>> this SHD would never stop running.
> >>>>>
> >>>>
> >>>> Nope, not when the input depends on the behavior of the decider in
> >>>> the way you are doing it.
> >>>
> >>> P was intentionally defined to depend on the behavior of its decider
> >>> *NITWIT*
> >>
> >> Right, but your "example" didn't, and this dependency is the case that
> >> breaks your "proof" and definitions.
> > The correct simulation of the input by H(P,P) is the simulation of this
> > input at the same point in the execution trace where H is invoked.
> >
> > (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> >
> >
> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> irrespective of "where" that simulation is done, at least if H is a
> computation, and if it isn't it can't be a decider.
>
> The CORRECT equivalent to the above would be:
>
> Add(2, 3) * 5 == 5 * Add(2, 3)
You shit for brains fucking idiot! That is not true.

On 9/4/22 3:08 AM, Skep Dick wrote:
> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com wrote:
>> On 9/3/22 1:18 PM, olcott wrote:
>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
>>>>>>>>>>>>>>>>> behind the answer all those not understanding these
>>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
>>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
>>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
>>>>>>>>>>>>>>>>> and reject it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
>>>>>>>>>>>>>>>> starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
>>>>>>>>>>>>>>>> of the words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
>>>>>>>>>>>>>>>> no one can help you with your logic.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
>>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
>>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
>>>>>>>>>>>>>>>> basd on the common name with a modifier).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
>>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
>>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
>>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
>>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
>>>>>>>>>>>>>>>>>>>> disputing that proof?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
>>>>>>>>>>>>>>>> using altered definition that you aren't providing.
>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
>>>>>>>>>>>>>>> incorrect basis.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
>>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
>>>>>>>>>>>>>
>>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
>>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
>>>>>>>>>>>>
>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When the correct and complete simulation of the input by
>>>>>>>>>>>>> H(P,P) would have different behavior than the direct
>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
>>>>>>>>>>>> Halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
>>>>>>>>>>> running unless H aborts the simulation of this input is merely
>>>>>>>>>>> another way of saying that the correct and complete simulation
>>>>>>>>>>> of this input by H never halts.
>>>>>>>>>>
>>>>>>>>>> You have bad logic there.
>>>>>>>>>
>>>>>>>>> It is a tautology:
>>>>>>>>>
>>>>>>>>> void Infinite_Loop()
>>>>>>>>> {
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _Infinite_Loop()
>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>
>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
>>>>>>>>> would never stop running unless H0 aborts the simulation of this
>>>>>>>>> input is merely another way of saying that the correct and
>>>>>>>>> complete simulation of this input by H0 never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Strawman.
>>>>>>>>
>>>>>>>> Fallacy of Proof by Example.
>>>>>>>
>>>>>>> It is only a fallacy by proof of example when a single example is
>>>>>>> not representative of the entire class of all such examples.
>>>>>>
>>>>>> Which it isn't, so FAIL.
>>>>>>
>>>>>>>
>>>>>>> You are confusing existential quantification with universal
>>>>>>> quantification.
>>>>>>
>>>>>> No you are, since you are claiming the rule works for ALL inputs (or
>>>>>> at least P, which isn't the input you showed it worked for).
>>>>>>
>>>>>>>
>>>>>>> ∀ simulating halt decider H
>>>>>>> ∀ machine description P
>>>>>>
>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>
>>>>>> You don't seem to know what those words mean.
>>>>>>
>>>>>>>
>>>>>>> The fact that the correct simulation of any input P to any
>>>>>>> simulating halt decider (SHD) H would never stop running unless
>>>>>>> this simulation was aborted by this SHD is merely another way of
>>>>>>> saying that the correct and complete simulation of this input by
>>>>>>> this SHD would never stop running.
>>>>>>>
>>>>>>
>>>>>> Nope, not when the input depends on the behavior of the decider in
>>>>>> the way you are doing it.
>>>>>
>>>>> P was intentionally defined to depend on the behavior of its decider
>>>>> *NITWIT*
>>>>
>>>> Right, but your "example" didn't, and this dependency is the case that
>>>> breaks your "proof" and definitions.
>>> The correct simulation of the input by H(P,P) is the simulation of this
>>> input at the same point in the execution trace where H is invoked.
>>>
>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>
>>>
>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>> irrespective of "where" that simulation is done, at least if H is a
>> computation, and if it isn't it can't be a decider.
>>
>> The CORRECT equivalent to the above would be:
>>
>> Add(2, 3) * 5 == 5 * Add(2, 3)
> You shit for brains fucking idiot! That is not true.
>
> https://en.wikipedia.org/wiki/Noncommutative_ring
>

On Sunday, 4 September 2022 at 12:56:47 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 3:08 AM, Skep Dick wrote:
> > On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com wrote:
> >> On 9/3/22 1:18 PM, olcott wrote:
> >>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>
> >>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
> >>>>>>>>>>>>>>>>> behind the answer all those not understanding these
> >>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
> >>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
> >>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
> >>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
> >>>>>>>>>>>>>>>>> and reject it.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
> >>>>>>>>>>>>>>>> starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
> >>>>>>>>>>>>>>>> of the words.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
> >>>>>>>>>>>>>>>> no one can help you with your logic.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
> >>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
> >>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
> >>>>>>>>>>>>>>>> basd on the common name with a modifier).
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
> >>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
> >>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
> >>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
> >>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
> >>>>>>>>>>>>>>>> proven what you claim to have proven.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
> >>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
> >>>>>>>>>>>>>>>>>>>> disputing that proof?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
> >>>>>>>>>>>>>>>> using altered definition that you aren't providing.
> >>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
> >>>>>>>>>>>>>>> incorrect basis.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
> >>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
> >>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
> >>>>>>>>>>>>
> >>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> When the correct and complete simulation of the input by
> >>>>>>>>>>>>> H(P,P) would have different behavior than the direct
> >>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
> >>>>>>>>>>>> Halts.
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
> >>>>>>>>>>> running unless H aborts the simulation of this input is merely
> >>>>>>>>>>> another way of saying that the correct and complete simulation
> >>>>>>>>>>> of this input by H never halts.
> >>>>>>>>>>
> >>>>>>>>>> You have bad logic there.
> >>>>>>>>>
> >>>>>>>>> It is a tautology:
> >>>>>>>>>
> >>>>>>>>> void Infinite_Loop()
> >>>>>>>>> {
> >>>>>>>>> HERE: goto HERE;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> _Infinite_Loop()
> >>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>
> >>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
> >>>>>>>>> would never stop running unless H0 aborts the simulation of this
> >>>>>>>>> input is merely another way of saying that the correct and
> >>>>>>>>> complete simulation of this input by H0 never halts.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Strawman.
> >>>>>>>>
> >>>>>>>> Fallacy of Proof by Example.
> >>>>>>>
> >>>>>>> It is only a fallacy by proof of example when a single example is
> >>>>>>> not representative of the entire class of all such examples.
> >>>>>>
> >>>>>> Which it isn't, so FAIL.
> >>>>>>
> >>>>>>>
> >>>>>>> You are confusing existential quantification with universal
> >>>>>>> quantification.
> >>>>>>
> >>>>>> No you are, since you are claiming the rule works for ALL inputs (or
> >>>>>> at least P, which isn't the input you showed it worked for).
> >>>>>>
> >>>>>>>
> >>>>>>> ∀ simulating halt decider H
> >>>>>>> ∀ machine description P
> >>>>>>
> >>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>
> >>>>>> You don't seem to know what those words mean.
> >>>>>>
> >>>>>>>
> >>>>>>> The fact that the correct simulation of any input P to any
> >>>>>>> simulating halt decider (SHD) H would never stop running unless
> >>>>>>> this simulation was aborted by this SHD is merely another way of
> >>>>>>> saying that the correct and complete simulation of this input by
> >>>>>>> this SHD would never stop running.
> >>>>>>>
> >>>>>>
> >>>>>> Nope, not when the input depends on the behavior of the decider in
> >>>>>> the way you are doing it.
> >>>>>
> >>>>> P was intentionally defined to depend on the behavior of its decider
> >>>>> *NITWIT*
> >>>>
> >>>> Right, but your "example" didn't, and this dependency is the case that
> >>>> breaks your "proof" and definitions.
> >>> The correct simulation of the input by H(P,P) is the simulation of this
> >>> input at the same point in the execution trace where H is invoked.
> >>>
> >>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> >>>
> >>>
> >> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >> irrespective of "where" that simulation is done, at least if H is a
> >> computation, and if it isn't it can't be a decider.
> >>
> >> The CORRECT equivalent to the above would be:
> >>
> >> Add(2, 3) * 5 == 5 * Add(2, 3)
> > You shit for brains fucking idiot! That is not true.
> >
> > https://en.wikipedia.org/wiki/Noncommutative_ring
> >
> Except both are 5 * 5 so the commutative property isn't needed.
>
> You are just being a DICK.
You shit for brains fucking idiot. It is axiomatic THAT x.y != y.x (1)

On Sunday, 4 September 2022 at 12:56:47 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 3:08 AM, Skep Dick wrote:
> > On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com wrote:
> >> On 9/3/22 1:18 PM, olcott wrote:
> >>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>
> >>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
> >>>>>>>>>>>>>>>>> behind the answer all those not understanding these
> >>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
> >>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
> >>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
> >>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
> >>>>>>>>>>>>>>>>> and reject it.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
> >>>>>>>>>>>>>>>> starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
> >>>>>>>>>>>>>>>> of the words.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
> >>>>>>>>>>>>>>>> no one can help you with your logic.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
> >>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
> >>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
> >>>>>>>>>>>>>>>> basd on the common name with a modifier).
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
> >>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
> >>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
> >>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
> >>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
> >>>>>>>>>>>>>>>> proven what you claim to have proven.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
> >>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
> >>>>>>>>>>>>>>>>>>>> disputing that proof?
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
> >>>>>>>>>>>>>>>> using altered definition that you aren't providing.
> >>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
> >>>>>>>>>>>>>>> incorrect basis.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
> >>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
> >>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
> >>>>>>>>>>>>
> >>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> When the correct and complete simulation of the input by
> >>>>>>>>>>>>> H(P,P) would have different behavior than the direct
> >>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
> >>>>>>>>>>>> Halts.
> >>>>>>>>>>>>
> >>>>>>>>>>>
> >>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
> >>>>>>>>>>> running unless H aborts the simulation of this input is merely
> >>>>>>>>>>> another way of saying that the correct and complete simulation
> >>>>>>>>>>> of this input by H never halts.
> >>>>>>>>>>
> >>>>>>>>>> You have bad logic there.
> >>>>>>>>>
> >>>>>>>>> It is a tautology:
> >>>>>>>>>
> >>>>>>>>> void Infinite_Loop()
> >>>>>>>>> {
> >>>>>>>>> HERE: goto HERE;
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> int main()
> >>>>>>>>> {
> >>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>> }
> >>>>>>>>>
> >>>>>>>>> _Infinite_Loop()
> >>>>>>>>> [00001102](01) 55 push ebp
> >>>>>>>>> [00001103](02) 8bec mov ebp,esp
> >>>>>>>>> [00001105](02) ebfe jmp 00001105
> >>>>>>>>> [00001107](01) 5d pop ebp
> >>>>>>>>> [00001108](01) c3 ret
> >>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>
> >>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
> >>>>>>>>> would never stop running unless H0 aborts the simulation of this
> >>>>>>>>> input is merely another way of saying that the correct and
> >>>>>>>>> complete simulation of this input by H0 never halts.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Strawman.
> >>>>>>>>
> >>>>>>>> Fallacy of Proof by Example.
> >>>>>>>
> >>>>>>> It is only a fallacy by proof of example when a single example is
> >>>>>>> not representative of the entire class of all such examples.
> >>>>>>
> >>>>>> Which it isn't, so FAIL.
> >>>>>>
> >>>>>>>
> >>>>>>> You are confusing existential quantification with universal
> >>>>>>> quantification.
> >>>>>>
> >>>>>> No you are, since you are claiming the rule works for ALL inputs (or
> >>>>>> at least P, which isn't the input you showed it worked for).
> >>>>>>
> >>>>>>>
> >>>>>>> ∀ simulating halt decider H
> >>>>>>> ∀ machine description P
> >>>>>>
> >>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>
> >>>>>> You don't seem to know what those words mean.
> >>>>>>
> >>>>>>>
> >>>>>>> The fact that the correct simulation of any input P to any
> >>>>>>> simulating halt decider (SHD) H would never stop running unless
> >>>>>>> this simulation was aborted by this SHD is merely another way of
> >>>>>>> saying that the correct and complete simulation of this input by
> >>>>>>> this SHD would never stop running.
> >>>>>>>
> >>>>>>
> >>>>>> Nope, not when the input depends on the behavior of the decider in
> >>>>>> the way you are doing it.
> >>>>>
> >>>>> P was intentionally defined to depend on the behavior of its decider
> >>>>> *NITWIT*
> >>>>
> >>>> Right, but your "example" didn't, and this dependency is the case that
> >>>> breaks your "proof" and definitions.
> >>> The correct simulation of the input by H(P,P) is the simulation of this
> >>> input at the same point in the execution trace where H is invoked.
> >>>
> >>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> >>>
> >>>
> >> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >> irrespective of "where" that simulation is done, at least if H is a
> >> computation, and if it isn't it can't be a decider.
> >>
> >> The CORRECT equivalent to the above would be:
> >>
> >> Add(2, 3) * 5 == 5 * Add(2, 3)
> > You shit for brains fucking idiot! That is not true.
> >
> > https://en.wikipedia.org/wiki/Noncommutative_ring
> >
> Except both are 5 * 5 so the commutative property isn't needed.
>
> You are just being a DICK.

On 9/4/2022 2:08 AM, Skep Dick wrote:
> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com wrote:
>> On 9/3/22 1:18 PM, olcott wrote:
>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
>>>>>>>>>>>>>>>>> behind the answer all those not understanding these
>>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
>>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
>>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
>>>>>>>>>>>>>>>>> and reject it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
>>>>>>>>>>>>>>>> starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
>>>>>>>>>>>>>>>> of the words.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
>>>>>>>>>>>>>>>> no one can help you with your logic.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
>>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
>>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
>>>>>>>>>>>>>>>> basd on the common name with a modifier).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
>>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
>>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
>>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
>>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
>>>>>>>>>>>>>>>>>>>> disputing that proof?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
>>>>>>>>>>>>>>>> using altered definition that you aren't providing.
>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
>>>>>>>>>>>>>>> incorrect basis.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
>>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
>>>>>>>>>>>>>
>>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
>>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
>>>>>>>>>>>>
>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> When the correct and complete simulation of the input by
>>>>>>>>>>>>> H(P,P) would have different behavior than the direct
>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
>>>>>>>>>>>> Halts.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
>>>>>>>>>>> running unless H aborts the simulation of this input is merely
>>>>>>>>>>> another way of saying that the correct and complete simulation
>>>>>>>>>>> of this input by H never halts.
>>>>>>>>>>
>>>>>>>>>> You have bad logic there.
>>>>>>>>>
>>>>>>>>> It is a tautology:
>>>>>>>>>
>>>>>>>>> void Infinite_Loop()
>>>>>>>>> {
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> _Infinite_Loop()
>>>>>>>>> [00001102](01) 55 push ebp
>>>>>>>>> [00001103](02) 8bec mov ebp,esp
>>>>>>>>> [00001105](02) ebfe jmp 00001105
>>>>>>>>> [00001107](01) 5d pop ebp
>>>>>>>>> [00001108](01) c3 ret
>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>
>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
>>>>>>>>> would never stop running unless H0 aborts the simulation of this
>>>>>>>>> input is merely another way of saying that the correct and
>>>>>>>>> complete simulation of this input by H0 never halts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Strawman.
>>>>>>>>
>>>>>>>> Fallacy of Proof by Example.
>>>>>>>
>>>>>>> It is only a fallacy by proof of example when a single example is
>>>>>>> not representative of the entire class of all such examples.
>>>>>>
>>>>>> Which it isn't, so FAIL.
>>>>>>
>>>>>>>
>>>>>>> You are confusing existential quantification with universal
>>>>>>> quantification.
>>>>>>
>>>>>> No you are, since you are claiming the rule works for ALL inputs (or
>>>>>> at least P, which isn't the input you showed it worked for).
>>>>>>
>>>>>>>
>>>>>>> ∀ simulating halt decider H
>>>>>>> ∀ machine description P
>>>>>>
>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>
>>>>>> You don't seem to know what those words mean.
>>>>>>
>>>>>>>
>>>>>>> The fact that the correct simulation of any input P to any
>>>>>>> simulating halt decider (SHD) H would never stop running unless
>>>>>>> this simulation was aborted by this SHD is merely another way of
>>>>>>> saying that the correct and complete simulation of this input by
>>>>>>> this SHD would never stop running.
>>>>>>>
>>>>>>
>>>>>> Nope, not when the input depends on the behavior of the decider in
>>>>>> the way you are doing it.
>>>>>
>>>>> P was intentionally defined to depend on the behavior of its decider
>>>>> *NITWIT*
>>>>
>>>> Right, but your "example" didn't, and this dependency is the case that
>>>> breaks your "proof" and definitions.
>>> The correct simulation of the input by H(P,P) is the simulation of this
>>> input at the same point in the execution trace where H is invoked.
>>>
>>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
>>>
>>>
>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>> irrespective of "where" that simulation is done, at least if H is a
>> computation, and if it isn't it can't be a decider.
>>
>> The CORRECT equivalent to the above would be:
>>
>> Add(2, 3) * 5 == 5 * Add(2, 3)
> You shit for brains fucking idiot! That is not true.
>
> https://en.wikipedia.org/wiki/Noncommutative_ring
>

On 9/4/2022 5:56 AM, Richard Damon wrote:
> On 9/4/22 3:08 AM, Skep Dick wrote:
>> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com
>> wrote:
>>> On 9/3/22 1:18 PM, olcott wrote:
>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
>>>>>>>>>>>>>>>>>> behind the answer all those not understanding these
>>>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
>>>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
>>>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
>>>>>>>>>>>>>>>>>> and reject it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
>>>>>>>>>>>>>>>>> starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
>>>>>>>>>>>>>>>>> of the words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
>>>>>>>>>>>>>>>>> no one can help you with your logic.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
>>>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
>>>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
>>>>>>>>>>>>>>>>> basd on the common name with a modifier).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
>>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
>>>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
>>>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
>>>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
>>>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
>>>>>>>>>>>>>>>>>>>>> disputing that proof?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
>>>>>>>>>>>>>>>>> using altered definition that you aren't providing.
>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
>>>>>>>>>>>>>>>> incorrect basis.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
>>>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
>>>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When the correct and complete simulation of the input by
>>>>>>>>>>>>>> H(P,P) would have different behavior than the direct
>>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
>>>>>>>>>>>> running unless H aborts the simulation of this input is merely
>>>>>>>>>>>> another way of saying that the correct and complete simulation
>>>>>>>>>>>> of this input by H never halts.
>>>>>>>>>>>
>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>
>>>>>>>>>> It is a tautology:
>>>>>>>>>>
>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>> {
>>>>>>>>>>     HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>     Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00001102](01)  55         push ebp
>>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>>>>>> [00001107](01)  5d         pop ebp
>>>>>>>>>> [00001108](01)  c3         ret
>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>
>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
>>>>>>>>>> would never stop running unless H0 aborts the simulation of this
>>>>>>>>>> input is merely another way of saying that the correct and
>>>>>>>>>> complete simulation of this input by H0 never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Strawman.
>>>>>>>>>
>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>
>>>>>>>> It is only a fallacy by proof of example when a single example is
>>>>>>>> not representative of the entire class of all such examples.
>>>>>>>
>>>>>>> Which it isn't, so FAIL.
>>>>>>>
>>>>>>>>
>>>>>>>> You are confusing existential quantification with universal
>>>>>>>> quantification.
>>>>>>>
>>>>>>> No you are, since you are claiming the rule works for ALL inputs (or
>>>>>>> at least P, which isn't the input you showed it worked for).
>>>>>>>
>>>>>>>>
>>>>>>>> ∀ simulating halt decider H
>>>>>>>> ∀ machine description P
>>>>>>>
>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>
>>>>>>> You don't seem to know what those words mean.
>>>>>>>
>>>>>>>>
>>>>>>>> The fact that the correct simulation of any input P to any
>>>>>>>> simulating halt decider (SHD) H would never stop running unless
>>>>>>>> this simulation was aborted by this SHD is merely another way of
>>>>>>>> saying that the correct and complete simulation of this input by
>>>>>>>> this SHD would never stop running.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, not when the input depends on the behavior of the decider in
>>>>>>> the way you are doing it.
>>>>>>
>>>>>> P was intentionally defined to depend on the behavior of its decider
>>>>>> *NITWIT*
>>>>>
>>>>> Right, but your "example" didn't, and this dependency is the case that
>>>>> breaks your "proof" and definitions.
>>>> The correct simulation of the input by H(P,P) is the simulation of this
>>>> input at the same point in the execution trace where H is invoked.
>>>>
>>>> (2 + 3) * 5   !=   2 + (3 * 5) // order matters.
>>>>
>>>>
>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>> irrespective of "where" that simulation is done, at least if H is a
>>> computation, and if it isn't it can't be a decider.
>>>
>>> The CORRECT equivalent to the above would be:
>>>
>>> Add(2, 3) * 5 == 5 * Add(2, 3)
>> You shit for brains fucking idiot! That is not true.
>>
>> https://en.wikipedia.org/wiki/Noncommutative_ring
>>
>
> Except both are 5 * 5 so the commutative property isn't needed.
>
> You are just being a DICK.

On 9/4/2022 5:56 AM, Richard Damon wrote:
> On 9/4/22 3:08 AM, Skep Dick wrote:
>> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com
>> wrote:
>>> On 9/3/22 1:18 PM, olcott wrote:
>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
>>>>>>>>>>>>>>>>>> behind the answer all those not understanding these
>>>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
>>>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
>>>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no basis
>>>>>>>>>>>>>>>>>> and reject it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
>>>>>>>>>>>>>>>>> starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
>>>>>>>>>>>>>>>>> of the words.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the words,
>>>>>>>>>>>>>>>>> no one can help you with your logic.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
>>>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
>>>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
>>>>>>>>>>>>>>>>> basd on the common name with a modifier).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as the
>>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
>>>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
>>>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
>>>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
>>>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
>>>>>>>>>>>>>>>>>>>>> disputing that proof?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
>>>>>>>>>>>>>>>>> using altered definition that you aren't providing.
>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
>>>>>>>>>>>>>>>> incorrect basis.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
>>>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
>>>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
>>>>>>>>>>>>>
>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When the correct and complete simulation of the input by
>>>>>>>>>>>>>> H(P,P) would have different behavior than the direct
>>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And the correct and complete simulation of the input to H(P,P)
>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input never stops
>>>>>>>>>>>> running unless H aborts the simulation of this input is merely
>>>>>>>>>>>> another way of saying that the correct and complete simulation
>>>>>>>>>>>> of this input by H never halts.
>>>>>>>>>>>
>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>
>>>>>>>>>> It is a tautology:
>>>>>>>>>>
>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>> {
>>>>>>>>>>     HERE: goto HERE;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>     Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00001102](01)  55         push ebp
>>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>>>>>> [00001107](01)  5d         pop ebp
>>>>>>>>>> [00001108](01)  c3         ret
>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>
>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
>>>>>>>>>> would never stop running unless H0 aborts the simulation of this
>>>>>>>>>> input is merely another way of saying that the correct and
>>>>>>>>>> complete simulation of this input by H0 never halts.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Strawman.
>>>>>>>>>
>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>
>>>>>>>> It is only a fallacy by proof of example when a single example is
>>>>>>>> not representative of the entire class of all such examples.
>>>>>>>
>>>>>>> Which it isn't, so FAIL.
>>>>>>>
>>>>>>>>
>>>>>>>> You are confusing existential quantification with universal
>>>>>>>> quantification.
>>>>>>>
>>>>>>> No you are, since you are claiming the rule works for ALL inputs (or
>>>>>>> at least P, which isn't the input you showed it worked for).
>>>>>>>
>>>>>>>>
>>>>>>>> ∀ simulating halt decider H
>>>>>>>> ∀ machine description P
>>>>>>>
>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>
>>>>>>> You don't seem to know what those words mean.
>>>>>>>
>>>>>>>>
>>>>>>>> The fact that the correct simulation of any input P to any
>>>>>>>> simulating halt decider (SHD) H would never stop running unless
>>>>>>>> this simulation was aborted by this SHD is merely another way of
>>>>>>>> saying that the correct and complete simulation of this input by
>>>>>>>> this SHD would never stop running.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, not when the input depends on the behavior of the decider in
>>>>>>> the way you are doing it.
>>>>>>
>>>>>> P was intentionally defined to depend on the behavior of its decider
>>>>>> *NITWIT*
>>>>>
>>>>> Right, but your "example" didn't, and this dependency is the case that
>>>>> breaks your "proof" and definitions.
>>>> The correct simulation of the input by H(P,P) is the simulation of this
>>>> input at the same point in the execution trace where H is invoked.
>>>>
>>>> (2 + 3) * 5   !=   2 + (3 * 5) // order matters.
>>>>
>>>>
>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>> irrespective of "where" that simulation is done, at least if H is a
>>> computation, and if it isn't it can't be a decider.
>>>
>>> The CORRECT equivalent to the above would be:
>>>
>>> Add(2, 3) * 5 == 5 * Add(2, 3)
>> You shit for brains fucking idiot! That is not true.
>>
>> https://en.wikipedia.org/wiki/Noncommutative_ring
>>
>
> Except both are 5 * 5 so the commutative property isn't needed.
>
> You are just being a DICK.

On 9/4/2022 8:41 AM, olcott wrote:
> On 9/4/2022 5:56 AM, Richard Damon wrote:
>> On 9/4/22 3:08 AM, Skep Dick wrote:
>>> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com
>>> wrote:
>>>> On 9/3/22 1:18 PM, olcott wrote:
>>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
>>>>>> On 9/3/22 12:56 PM, olcott wrote:
>>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
>>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
>>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
>>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
>>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
>>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
>>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
>>>>>>>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the reasoning
>>>>>>>>>>>>>>>>>>> behind the answer all those not understanding these
>>>>>>>>>>>>>>>>>>> things cannot simply baselessly disagree. All
>>>>>>>>>>>>>>>>>>> disagreement is thus required to have a basis. This way
>>>>>>>>>>>>>>>>>>> people are not lead astray by a bunch of baseless
>>>>>>>>>>>>>>>>>>> disagreement, they see that the disagreement has no
>>>>>>>>>>>>>>>>>>> basis
>>>>>>>>>>>>>>>>>>> and reject it.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID reasoning,
>>>>>>>>>>>>>>>>>> starting from ACCEPTED definition.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You just make wild claims based on your own understanding
>>>>>>>>>>>>>>>>>> of the words.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the
>>>>>>>>>>>>>>>>>> words,
>>>>>>>>>>>>>>>>>> no one can help you with your logic.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE well
>>>>>>>>>>>>>>>>>> defined meanings, so you either need to use that meaning,
>>>>>>>>>>>>>>>>>> or you really need to give your idea a new name (maybe
>>>>>>>>>>>>>>>>>> basd on the common name with a modifier).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same as
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it clear that
>>>>>>>>>>>>>>>>>> you are talking about the PO-Halting Problem, with a
>>>>>>>>>>>>>>>>>> PO-Halting Decider, so you counter example doesn't affect
>>>>>>>>>>>>>>>>>> the actual Halting Problem, so it is clear you haven't
>>>>>>>>>>>>>>>>>> proven what you claim to have proven.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be proved
>>>>>>>>>>>>>>>>>>>>>> that the definition is self-contradictory. You're not
>>>>>>>>>>>>>>>>>>>>>> disputing that proof?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are clearly
>>>>>>>>>>>>>>>>>> using altered definition that you aren't providing.
>>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting with an
>>>>>>>>>>>>>>>>> incorrect basis.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d) by
>>>>>>>>>>>>>>>> DEFINITION gives the exact same result as P(d).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When you get a glass of water and dump it on the floor you
>>>>>>>>>>>>>>> cannot truthfully deny that the floor is wet.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And I haven't
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When the correct and complete simulation of the input by
>>>>>>>>>>>>>>> H(P,P) would have different behavior than the direct
>>>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And the correct and complete simulation of the input to
>>>>>>>>>>>>>> H(P,P)
>>>>>>>>>>>>>> Halts.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input never
>>>>>>>>>>>>> stops
>>>>>>>>>>>>> running unless H aborts the simulation of this input is merely
>>>>>>>>>>>>> another way of saying that the correct and complete simulation
>>>>>>>>>>>>> of this input by H never halts.
>>>>>>>>>>>>
>>>>>>>>>>>> You have bad logic there.
>>>>>>>>>>>
>>>>>>>>>>> It is a tautology:
>>>>>>>>>>>
>>>>>>>>>>> void Infinite_Loop()
>>>>>>>>>>> {
>>>>>>>>>>>     HERE: goto HERE;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>     Output("Input_Halts = ", H0((u32)Infinite_Loop));
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>> [00001102](01)  55         push ebp
>>>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
>>>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
>>>>>>>>>>> [00001107](01)  5d         pop ebp
>>>>>>>>>>> [00001108](01)  c3         ret
>>>>>>>>>>> Size in bytes:(0007) [00001108]
>>>>>>>>>>>
>>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its input
>>>>>>>>>>> would never stop running unless H0 aborts the simulation of this
>>>>>>>>>>> input is merely another way of saying that the correct and
>>>>>>>>>>> complete simulation of this input by H0 never halts.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Strawman.
>>>>>>>>>>
>>>>>>>>>> Fallacy of Proof by Example.
>>>>>>>>>
>>>>>>>>> It is only a fallacy by proof of example when a single example is
>>>>>>>>> not representative of the entire class of all such examples.
>>>>>>>>
>>>>>>>> Which it isn't, so FAIL.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are confusing existential quantification with universal
>>>>>>>>> quantification.
>>>>>>>>
>>>>>>>> No you are, since you are claiming the rule works for ALL inputs
>>>>>>>> (or
>>>>>>>> at least P, which isn't the input you showed it worked for).
>>>>>>>>
>>>>>>>>>
>>>>>>>>> ∀ simulating halt decider H
>>>>>>>>> ∀ machine description P
>>>>>>>>
>>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
>>>>>>>>
>>>>>>>> You don't seem to know what those words mean.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> The fact that the correct simulation of any input P to any
>>>>>>>>> simulating halt decider (SHD) H would never stop running unless
>>>>>>>>> this simulation was aborted by this SHD is merely another way of
>>>>>>>>> saying that the correct and complete simulation of this input by
>>>>>>>>> this SHD would never stop running.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, not when the input depends on the behavior of the decider in
>>>>>>>> the way you are doing it.
>>>>>>>
>>>>>>> P was intentionally defined to depend on the behavior of its decider
>>>>>>> *NITWIT*
>>>>>>
>>>>>> Right, but your "example" didn't, and this dependency is the case
>>>>>> that
>>>>>> breaks your "proof" and definitions.
>>>>> The correct simulation of the input by H(P,P) is the simulation of
>>>>> this
>>>>> input at the same point in the execution trace where H is invoked.
>>>>>
>>>>> (2 + 3) * 5   !=   2 + (3 * 5) // order matters.
>>>>>
>>>>>
>>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
>>>> irrespective of "where" that simulation is done, at least if H is a
>>>> computation, and if it isn't it can't be a decider.
>>>>
>>>> The CORRECT equivalent to the above would be:
>>>>
>>>> Add(2, 3) * 5 == 5 * Add(2, 3)
>>> You shit for brains fucking idiot! That is not true.
>>>
>>> https://en.wikipedia.org/wiki/Noncommutative_ring
>>>
>>
>> Except both are 5 * 5 so the commutative property isn't needed.
>>
>> You are just being a DICK.
>
> (2 + 3) * 5  == 25 // 2+3== 5 then 5* 5==25
>  2 + (3 * 5) == 17 // 3*5==15 then 2+15==17
>
> If you can't even correctly compute 8th grade arithmetic how can you
> possibly have sufficient knowledge of more complex computations?
>
>

On Sun, 4 Sep 2022 00:08:22 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Saturday, 3 September 2022 at 19:24:40 UTC+2, richar...@gmail.com
> wrote:
> > On 9/3/22 1:18 PM, olcott wrote:
> > > On 9/3/2022 12:08 PM, Richard Damon wrote:
> > >> On 9/3/22 12:56 PM, olcott wrote:
> > >>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> > >>>> On 9/3/22 12:32 PM, olcott wrote:
> > >>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> > >>>>>>
> > >>>>>> On 9/3/22 12:05 PM, olcott wrote:
> > >>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> > >>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> > >>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> > >>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> > >>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> > >>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> > >>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> > >>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> > >>>>>>>>>>>>>>>> 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.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>> When I provide a complete explanation of the
> > >>>>>>>>>>>>>>> reasoning behind the answer all those not
> > >>>>>>>>>>>>>>> understanding these things cannot simply baselessly
> > >>>>>>>>>>>>>>> disagree. All disagreement is thus required to have
> > >>>>>>>>>>>>>>> a basis. This way people are not lead astray by a
> > >>>>>>>>>>>>>>> bunch of baseless disagreement, they see that the
> > >>>>>>>>>>>>>>> disagreement has no basis and reject it.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> So, you need to try to actually provide VALID
> > >>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> You just make wild claims based on your own
> > >>>>>>>>>>>>>> understanding of the words.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the
> > >>>>>>>>>>>>>> words, no one can help you with your logic.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE
> > >>>>>>>>>>>>>> well defined meanings, so you either need to use
> > >>>>>>>>>>>>>> that meaning, or you really need to give your idea a
> > >>>>>>>>>>>>>> new name (maybe basd on the common name with a
> > >>>>>>>>>>>>>> modifier).
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same
> > >>>>>>>>>>>>>> as the accepted definition, you can call it
> > >>>>>>>>>>>>>> PO-Halting.
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> Of course the problem with this is it makes it clear
> > >>>>>>>>>>>>>> that you are talking about the PO-Halting Problem,
> > >>>>>>>>>>>>>> with a PO-Halting Decider, so you counter example
> > >>>>>>>>>>>>>> doesn't affect the actual Halting Problem, so it is
> > >>>>>>>>>>>>>> clear you haven't proven what you claim to have
> > >>>>>>>>>>>>>> proven.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> > >>>>>>>>>>>>>>>>>> proved that the definition is
> > >>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing that
> > >>>>>>>>>>>>>>>>>> proof?
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> You haven't actually given a proof, since you are
> > >>>>>>>>>>>>>> clearly using altered definition that you aren't
> > >>>>>>>>>>>>>> providing.
> > >>>>>>>>>>>>> You reject the notion of a UTM so you are starting
> > >>>>>>>>>>>>> with an incorrect basis.
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d)
> > >>>>>>>>>>>> by DEFINITION gives the exact same result as P(d).
> > >>>>>>>>>>>
> > >>>>>>>>>>> When you get a glass of water and dump it on the floor
> > >>>>>>>>>>> you cannot truthfully deny that the floor is wet.
> > >>>>>>>>>>
> > >>>>>>>>>> And I haven't
> > >>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> When the correct and complete simulation of the input
> > >>>>>>>>>>> by H(P,P) would have different behavior than the direct
> > >>>>>>>>>>> execution of P(P) this cannot simply be ignored.
> > >>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>
> > >>>>>>>>>> And the correct and complete simulation of the input to
> > >>>>>>>>>> H(P,P) Halts.
> > >>>>>>>>>>
> > >>>>>>>>>
> > >>>>>>>>> The fact that the simulation by H(P,P) of its input never
> > >>>>>>>>> stops running unless H aborts the simulation of this
> > >>>>>>>>> input is merely another way of saying that the correct
> > >>>>>>>>> and complete simulation of this input by H never halts.
> > >>>>>>>>
> > >>>>>>>> You have bad logic there.
> > >>>>>>>
> > >>>>>>> It is a tautology:
> > >>>>>>>
> > >>>>>>> void Infinite_Loop()
> > >>>>>>> {
> > >>>>>>> HERE: goto HERE;
> > >>>>>>> }
> > >>>>>>>
> > >>>>>>> int main()
> > >>>>>>> {
> > >>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> > >>>>>>> }
> > >>>>>>>
> > >>>>>>> _Infinite_Loop()
> > >>>>>>> [00001102](01) 55 push ebp
> > >>>>>>> [00001103](02) 8bec mov ebp,esp
> > >>>>>>> [00001105](02) ebfe jmp 00001105
> > >>>>>>> [00001107](01) 5d pop ebp
> > >>>>>>> [00001108](01) c3 ret
> > >>>>>>> Size in bytes:(0007) [00001108]
> > >>>>>>>
> > >>>>>>> The fact that the simulation by H0(Infinite_Loop) of its
> > >>>>>>> input would never stop running unless H0 aborts the
> > >>>>>>> simulation of this input is merely another way of saying
> > >>>>>>> that the correct and complete simulation of this input by
> > >>>>>>> H0 never halts.
> > >>>>>>
> > >>>>>> Strawman.
> > >>>>>>
> > >>>>>> Fallacy of Proof by Example.
> > >>>>>
> > >>>>> It is only a fallacy by proof of example when a single
> > >>>>> example is not representative of the entire class of all such
> > >>>>> examples.
> > >>>>
> > >>>> Which it isn't, so FAIL.
> > >>>>
> > >>>>>
> > >>>>> You are confusing existential quantification with universal
> > >>>>> quantification.
> > >>>>
> > >>>> No you are, since you are claiming the rule works for ALL
> > >>>> inputs (or at least P, which isn't the input you showed it
> > >>>> worked for).
> > >>>>>
> > >>>>> ∀ simulating halt decider H
> > >>>>> ∀ machine description P
> > >>>>
> > >>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> > >>>>
> > >>>> You don't seem to know what those words mean.
> > >>>>
> > >>>>>
> > >>>>> The fact that the correct simulation of any input P to any
> > >>>>> simulating halt decider (SHD) H would never stop running
> > >>>>> unless this simulation was aborted by this SHD is merely
> > >>>>> another way of saying that the correct and complete
> > >>>>> simulation of this input by this SHD would never stop
> > >>>>> running.
> > >>>>
> > >>>> Nope, not when the input depends on the behavior of the
> > >>>> decider in the way you are doing it.
> > >>>
> > >>> P was intentionally defined to depend on the behavior of its
> > >>> decider *NITWIT*
> > >>
> > >> Right, but your "example" didn't, and this dependency is the
> > >> case that breaks your "proof" and definitions.
> > > The correct simulation of the input by H(P,P) is the simulation
> > > of this input at the same point in the execution trace where H is
> > > invoked.
> > >
> > > (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> > >
> > >
> > Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> > irrespective of "where" that simulation is done, at least if H is a
> > computation, and if it isn't it can't be a decider.
> >
> > The CORRECT equivalent to the above would be:
> >
> > Add(2, 3) * 5 == 5 * Add(2, 3)
> You shit for brains fucking idiot! That is not true.
>
> https://en.wikipedia.org/wiki/Noncommutative_ring

On Sun, 4 Sep 2022 08:41:52 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/4/2022 5:56 AM, Richard Damon wrote:
> > On 9/4/22 3:08 AM, Skep Dick wrote:
> >> On Saturday, 3 September 2022 at 19:24:40 UTC+2,
> >> richar...@gmail.com wrote:
> >>> On 9/3/22 1:18 PM, olcott wrote:
> >>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>>
> >>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> >>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> >>>>>>>>>>>>>>>>>> understanding these things cannot simply
> >>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> >>>>>>>>>>>>>>>>>> required to have a basis. This way people are not
> >>>>>>>>>>>>>>>>>> lead astray by a bunch of baseless disagreement,
> >>>>>>>>>>>>>>>>>> they see that the disagreement has no basis and
> >>>>>>>>>>>>>>>>>> reject it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> >>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You just make wild claims based on your own
> >>>>>>>>>>>>>>>>> understanding of the words.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the
> >>>>>>>>>>>>>>>>> words, no one can help you with your logic.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE
> >>>>>>>>>>>>>>>>> well defined meanings, so you either need to use
> >>>>>>>>>>>>>>>>> that meaning, or you really need to give your idea
> >>>>>>>>>>>>>>>>> a new name (maybe basd on the common name with a
> >>>>>>>>>>>>>>>>> modifier).
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same
> >>>>>>>>>>>>>>>>> as the accepted definition, you can call it
> >>>>>>>>>>>>>>>>> PO-Halting.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> >>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> >>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you counter
> >>>>>>>>>>>>>>>>> example doesn't affect the actual Halting Problem,
> >>>>>>>>>>>>>>>>> so it is clear you haven't proven what you claim to
> >>>>>>>>>>>>>>>>> have proven.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> >>>>>>>>>>>>>>>>>>>>> proved that the definition is
> >>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing that
> >>>>>>>>>>>>>>>>>>>>> proof?
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are
> >>>>>>>>>>>>>>>>> clearly using altered definition that you aren't
> >>>>>>>>>>>>>>>>> providing.
> >>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting
> >>>>>>>>>>>>>>>> with an incorrect basis.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d)
> >>>>>>>>>>>>>>> by DEFINITION gives the exact same result as P(d).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> When you get a glass of water and dump it on the floor
> >>>>>>>>>>>>>> you cannot truthfully deny that the floor is wet.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> When the correct and complete simulation of the input
> >>>>>>>>>>>>>> by H(P,P) would have different behavior than the direct
> >>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> And the correct and complete simulation of the input to
> >>>>>>>>>>>>> H(P,P) Halts.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> >>>>>>>>>>>> never stops running unless H aborts the simulation of
> >>>>>>>>>>>> this input is merely another way of saying that the
> >>>>>>>>>>>> correct and complete simulation of this input by H never
> >>>>>>>>>>>> halts.
> >>>>>>>>>>>
> >>>>>>>>>>> You have bad logic there.
> >>>>>>>>>>
> >>>>>>>>>> It is a tautology:
> >>>>>>>>>>
> >>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>> {
> >>>>>>>>>>     HERE: goto HERE;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>>     Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>> [00001102](01)  55         push ebp
> >>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
> >>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
> >>>>>>>>>> [00001107](01)  5d         pop ebp
> >>>>>>>>>> [00001108](01)  c3         ret
> >>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>
> >>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its
> >>>>>>>>>> input would never stop running unless H0 aborts the
> >>>>>>>>>> simulation of this input is merely another way of saying
> >>>>>>>>>> that the correct and complete simulation of this input by
> >>>>>>>>>> H0 never halts.
> >>>>>>>>>
> >>>>>>>>> Strawman.
> >>>>>>>>>
> >>>>>>>>> Fallacy of Proof by Example.
> >>>>>>>>
> >>>>>>>> It is only a fallacy by proof of example when a single
> >>>>>>>> example is not representative of the entire class of all
> >>>>>>>> such examples.
> >>>>>>>
> >>>>>>> Which it isn't, so FAIL.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> You are confusing existential quantification with universal
> >>>>>>>> quantification.
> >>>>>>>
> >>>>>>> No you are, since you are claiming the rule works for ALL
> >>>>>>> inputs (or at least P, which isn't the input you showed it
> >>>>>>> worked for).
> >>>>>>>>
> >>>>>>>> ∀ simulating halt decider H
> >>>>>>>> ∀ machine description P
> >>>>>>>
> >>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>>
> >>>>>>> You don't seem to know what those words mean.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> The fact that the correct simulation of any input P to any
> >>>>>>>> simulating halt decider (SHD) H would never stop running
> >>>>>>>> unless this simulation was aborted by this SHD is merely
> >>>>>>>> another way of saying that the correct and complete
> >>>>>>>> simulation of this input by this SHD would never stop
> >>>>>>>> running.
> >>>>>>>
> >>>>>>> Nope, not when the input depends on the behavior of the
> >>>>>>> decider in the way you are doing it.
> >>>>>>
> >>>>>> P was intentionally defined to depend on the behavior of its
> >>>>>> decider *NITWIT*
> >>>>>
> >>>>> Right, but your "example" didn't, and this dependency is the
> >>>>> case that breaks your "proof" and definitions.
> >>>> The correct simulation of the input by H(P,P) is the simulation
> >>>> of this input at the same point in the execution trace where H
> >>>> is invoked.
> >>>>
> >>>> (2 + 3) * 5   !=   2 + (3 * 5) // order matters.
> >>>>
> >>>>
> >>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >>> irrespective of "where" that simulation is done, at least if H is
> >>> a computation, and if it isn't it can't be a decider.
> >>>
> >>> The CORRECT equivalent to the above would be:
> >>>
> >>> Add(2, 3) * 5 == 5 * Add(2, 3)
> >> You shit for brains fucking idiot! That is not true.
> >>
> >> https://en.wikipedia.org/wiki/Noncommutative_ring
> >>
> >
> > Except both are 5 * 5 so the commutative property isn't needed.
> >
> > You are just being a DICK.
>
> (2 + 3) * 5 == 25 // 2+3== 5 then 5* 5==25
> 2 + (3 * 5) == 17 // 3*5==15 then 2+15==17
>
> If you can't even correctly compute 8th grade arithmetic how can you
> possibly have sufficient knowledge of more complex computations?

On Sun, 4 Sep 2022 09:42:51 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/4/2022 8:41 AM, olcott wrote:
> > On 9/4/2022 5:56 AM, Richard Damon wrote:
> >> On 9/4/22 3:08 AM, Skep Dick wrote:
> >>> On Saturday, 3 September 2022 at 19:24:40 UTC+2,
> >>> richar...@gmail.com wrote:
> >>>> On 9/3/22 1:18 PM, olcott wrote:
> >>>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>>>
> >>>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> >>>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> >>>>>>>>>>>>>>>>>>> understanding these things cannot simply
> >>>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> >>>>>>>>>>>>>>>>>>> required to have a basis. This way people are not
> >>>>>>>>>>>>>>>>>>> lead astray by a bunch of baseless disagreement,
> >>>>>>>>>>>>>>>>>>> they see that the disagreement has no basis
> >>>>>>>>>>>>>>>>>>> and reject it.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> >>>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You just make wild claims based on your own
> >>>>>>>>>>>>>>>>>> understanding of the words.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
> >>>>>>>>>>>>>>>>>> the words,
> >>>>>>>>>>>>>>>>>> no one can help you with your logic.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Note, Most of the things you are talking about
> >>>>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need to
> >>>>>>>>>>>>>>>>>> use that meaning, or you really need to give your
> >>>>>>>>>>>>>>>>>> idea a new name (maybe basd on the common name
> >>>>>>>>>>>>>>>>>> with a modifier).
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
> >>>>>>>>>>>>>>>>>> same as the
> >>>>>>>>>>>>>>>>>> accepted definition, you can call it PO-Halting.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> >>>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> >>>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you counter
> >>>>>>>>>>>>>>>>>> example doesn't affect the actual Halting Problem,
> >>>>>>>>>>>>>>>>>> so it is clear you haven't proven what you claim
> >>>>>>>>>>>>>>>>>> to have proven.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> >>>>>>>>>>>>>>>>>>>>>> proved that the definition is
> >>>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing that
> >>>>>>>>>>>>>>>>>>>>>> proof?
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are
> >>>>>>>>>>>>>>>>>> clearly using altered definition that you aren't
> >>>>>>>>>>>>>>>>>> providing.
> >>>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting
> >>>>>>>>>>>>>>>>> with an incorrect basis.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d)
> >>>>>>>>>>>>>>>> by DEFINITION gives the exact same result as P(d).
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> When you get a glass of water and dump it on the
> >>>>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
> >>>>>>>>>>>>>>> wet.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> When the correct and complete simulation of the input
> >>>>>>>>>>>>>>> by H(P,P) would have different behavior than the
> >>>>>>>>>>>>>>> direct execution of P(P) this cannot simply be
> >>>>>>>>>>>>>>> ignored.
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> And the correct and complete simulation of the input
> >>>>>>>>>>>>>> to H(P,P)
> >>>>>>>>>>>>>> Halts.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> >>>>>>>>>>>>> never stops
> >>>>>>>>>>>>> running unless H aborts the simulation of this input is
> >>>>>>>>>>>>> merely another way of saying that the correct and
> >>>>>>>>>>>>> complete simulation of this input by H never halts.
> >>>>>>>>>>>>
> >>>>>>>>>>>> You have bad logic there.
> >>>>>>>>>>>
> >>>>>>>>>>> It is a tautology:
> >>>>>>>>>>>
> >>>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>>> {
> >>>>>>>>>>>     HERE: goto HERE;
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> int main()
> >>>>>>>>>>> {
> >>>>>>>>>>>     Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>>> }
> >>>>>>>>>>>
> >>>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>>> [00001102](01)  55         push ebp
> >>>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
> >>>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
> >>>>>>>>>>> [00001107](01)  5d         pop ebp
> >>>>>>>>>>> [00001108](01)  c3         ret
> >>>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>>
> >>>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its
> >>>>>>>>>>> input would never stop running unless H0 aborts the
> >>>>>>>>>>> simulation of this input is merely another way of saying
> >>>>>>>>>>> that the correct and complete simulation of this input by
> >>>>>>>>>>> H0 never halts.
> >>>>>>>>>>
> >>>>>>>>>> Strawman.
> >>>>>>>>>>
> >>>>>>>>>> Fallacy of Proof by Example.
> >>>>>>>>>
> >>>>>>>>> It is only a fallacy by proof of example when a single
> >>>>>>>>> example is not representative of the entire class of all
> >>>>>>>>> such examples.
> >>>>>>>>
> >>>>>>>> Which it isn't, so FAIL.
> >>>>>>>>
> >>>>>>>>>
> >>>>>>>>> You are confusing existential quantification with universal
> >>>>>>>>> quantification.
> >>>>>>>>
> >>>>>>>> No you are, since you are claiming the rule works for ALL
> >>>>>>>> inputs (or
> >>>>>>>> at least P, which isn't the input you showed it worked for).
> >>>>>>>>
> >>>>>>>>>
> >>>>>>>>> ∀ simulating halt decider H
> >>>>>>>>> ∀ machine description P
> >>>>>>>>
> >>>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>>>
> >>>>>>>> You don't seem to know what those words mean.
> >>>>>>>>
> >>>>>>>>>
> >>>>>>>>> The fact that the correct simulation of any input P to any
> >>>>>>>>> simulating halt decider (SHD) H would never stop running
> >>>>>>>>> unless this simulation was aborted by this SHD is merely
> >>>>>>>>> another way of saying that the correct and complete
> >>>>>>>>> simulation of this input by this SHD would never stop
> >>>>>>>>> running.
> >>>>>>>>
> >>>>>>>> Nope, not when the input depends on the behavior of the
> >>>>>>>> decider in the way you are doing it.
> >>>>>>>
> >>>>>>> P was intentionally defined to depend on the behavior of its
> >>>>>>> decider *NITWIT*
> >>>>>>
> >>>>>> Right, but your "example" didn't, and this dependency is the
> >>>>>> case that
> >>>>>> breaks your "proof" and definitions.
> >>>>> The correct simulation of the input by H(P,P) is the simulation
> >>>>> of this
> >>>>> input at the same point in the execution trace where H is
> >>>>> invoked.
> >>>>>
> >>>>> (2 + 3) * 5   !=   2 + (3 * 5) // order matters.
> >>>>>
> >>>>>
> >>>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >>>> irrespective of "where" that simulation is done, at least if H
> >>>> is a computation, and if it isn't it can't be a decider.
> >>>>
> >>>> The CORRECT equivalent to the above would be:
> >>>>
> >>>> Add(2, 3) * 5 == 5 * Add(2, 3)
> >>> You shit for brains fucking idiot! That is not true.
> >>>
> >>> https://en.wikipedia.org/wiki/Noncommutative_ring
> >>>
> >>
> >> Except both are 5 * 5 so the commutative property isn't needed.
> >>
> >> You are just being a DICK.
> >
> > (2 + 3) * 5  == 25 // 2+3== 5 then 5* 5==25
> >  2 + (3 * 5) == 17 // 3*5==15 then 2+15==17
> >
> > If you can't even correctly compute 8th grade arithmetic how can
> > you possibly have sufficient knowledge of more complex computations?
> >
> >
>
> #include <cstdio>
>
> int main()
> {
> printf("(2 + 3) * 5 == %d\n", (2 + 3) * 5);
> printf("2 + (3 * 5) == %d\n", 2 + (3 * 5));
> }
>
> (2 + 3) * 5 == 25
> 2 + (3 * 5) == 17

On Sun, 4 Sep 2022 08:15:44 -0500
olcott <polcott2@gmail.com> wrote:

> On 9/4/2022 5:56 AM, Richard Damon wrote:
> > On 9/4/22 3:08 AM, Skep Dick wrote:
> >> On Saturday, 3 September 2022 at 19:24:40 UTC+2,
> >> richar...@gmail.com wrote:
> >>> On 9/3/22 1:18 PM, olcott wrote:
> >>>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> >>>>> On 9/3/22 12:56 PM, olcott wrote:
> >>>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> >>>>>>> On 9/3/22 12:32 PM, olcott wrote:
> >>>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> >>>>>>>>>
> >>>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> >>>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> >>>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> >>>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> >>>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> >>>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> >>>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> >>>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> >>>>>>>>>>>>>>>>>>> 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.
> >>>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> >>>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> >>>>>>>>>>>>>>>>>> understanding these things cannot simply
> >>>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> >>>>>>>>>>>>>>>>>> required to have a basis. This way people are not
> >>>>>>>>>>>>>>>>>> lead astray by a bunch of baseless disagreement,
> >>>>>>>>>>>>>>>>>> they see that the disagreement has no basis and
> >>>>>>>>>>>>>>>>>> reject it.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> >>>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You just make wild claims based on your own
> >>>>>>>>>>>>>>>>> understanding of the words.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE the
> >>>>>>>>>>>>>>>>> words, no one can help you with your logic.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Note, Most of the things you are talking about HAVE
> >>>>>>>>>>>>>>>>> well defined meanings, so you either need to use
> >>>>>>>>>>>>>>>>> that meaning, or you really need to give your idea
> >>>>>>>>>>>>>>>>> a new name (maybe basd on the common name with a
> >>>>>>>>>>>>>>>>> modifier).
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the same
> >>>>>>>>>>>>>>>>> as the accepted definition, you can call it
> >>>>>>>>>>>>>>>>> PO-Halting.
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> >>>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> >>>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you counter
> >>>>>>>>>>>>>>>>> example doesn't affect the actual Halting Problem,
> >>>>>>>>>>>>>>>>> so it is clear you haven't proven what you claim to
> >>>>>>>>>>>>>>>>> have proven.
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> >>>>>>>>>>>>>>>>>>>>> proved that the definition is
> >>>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing that
> >>>>>>>>>>>>>>>>>>>>> proof?
> >>>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>>> You haven't actually given a proof, since you are
> >>>>>>>>>>>>>>>>> clearly using altered definition that you aren't
> >>>>>>>>>>>>>>>>> providing.
> >>>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting
> >>>>>>>>>>>>>>>> with an incorrect basis.
> >>>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>>
> >>>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d)
> >>>>>>>>>>>>>>> by DEFINITION gives the exact same result as P(d).
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> When you get a glass of water and dump it on the floor
> >>>>>>>>>>>>>> you cannot truthfully deny that the floor is wet.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> And I haven't
> >>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>> When the correct and complete simulation of the input
> >>>>>>>>>>>>>> by H(P,P) would have different behavior than the direct
> >>>>>>>>>>>>>> execution of P(P) this cannot simply be ignored.
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>>
> >>>>>>>>>>>>>
> >>>>>>>>>>>>> And the correct and complete simulation of the input to
> >>>>>>>>>>>>> H(P,P) Halts.
> >>>>>>>>>>>>>
> >>>>>>>>>>>>
> >>>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> >>>>>>>>>>>> never stops running unless H aborts the simulation of
> >>>>>>>>>>>> this input is merely another way of saying that the
> >>>>>>>>>>>> correct and complete simulation of this input by H never
> >>>>>>>>>>>> halts.
> >>>>>>>>>>>
> >>>>>>>>>>> You have bad logic there.
> >>>>>>>>>>
> >>>>>>>>>> It is a tautology:
> >>>>>>>>>>
> >>>>>>>>>> void Infinite_Loop()
> >>>>>>>>>> {
> >>>>>>>>>>     HERE: goto HERE;
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> int main()
> >>>>>>>>>> {
> >>>>>>>>>>     Output("Input_Halts = ", H0((u32)Infinite_Loop));
> >>>>>>>>>> }
> >>>>>>>>>>
> >>>>>>>>>> _Infinite_Loop()
> >>>>>>>>>> [00001102](01)  55         push ebp
> >>>>>>>>>> [00001103](02)  8bec       mov ebp,esp
> >>>>>>>>>> [00001105](02)  ebfe       jmp 00001105
> >>>>>>>>>> [00001107](01)  5d         pop ebp
> >>>>>>>>>> [00001108](01)  c3         ret
> >>>>>>>>>> Size in bytes:(0007) [00001108]
> >>>>>>>>>>
> >>>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its
> >>>>>>>>>> input would never stop running unless H0 aborts the
> >>>>>>>>>> simulation of this input is merely another way of saying
> >>>>>>>>>> that the correct and complete simulation of this input by
> >>>>>>>>>> H0 never halts.
> >>>>>>>>>
> >>>>>>>>> Strawman.
> >>>>>>>>>
> >>>>>>>>> Fallacy of Proof by Example.
> >>>>>>>>
> >>>>>>>> It is only a fallacy by proof of example when a single
> >>>>>>>> example is not representative of the entire class of all
> >>>>>>>> such examples.
> >>>>>>>
> >>>>>>> Which it isn't, so FAIL.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> You are confusing existential quantification with universal
> >>>>>>>> quantification.
> >>>>>>>
> >>>>>>> No you are, since you are claiming the rule works for ALL
> >>>>>>> inputs (or at least P, which isn't the input you showed it
> >>>>>>> worked for).
> >>>>>>>>
> >>>>>>>> ∀ simulating halt decider H
> >>>>>>>> ∀ machine description P
> >>>>>>>
> >>>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> >>>>>>>
> >>>>>>> You don't seem to know what those words mean.
> >>>>>>>
> >>>>>>>>
> >>>>>>>> The fact that the correct simulation of any input P to any
> >>>>>>>> simulating halt decider (SHD) H would never stop running
> >>>>>>>> unless this simulation was aborted by this SHD is merely
> >>>>>>>> another way of saying that the correct and complete
> >>>>>>>> simulation of this input by this SHD would never stop
> >>>>>>>> running.
> >>>>>>>
> >>>>>>> Nope, not when the input depends on the behavior of the
> >>>>>>> decider in the way you are doing it.
> >>>>>>
> >>>>>> P was intentionally defined to depend on the behavior of its
> >>>>>> decider *NITWIT*
> >>>>>
> >>>>> Right, but your "example" didn't, and this dependency is the
> >>>>> case that breaks your "proof" and definitions.
> >>>> The correct simulation of the input by H(P,P) is the simulation
> >>>> of this input at the same point in the execution trace where H
> >>>> is invoked.
> >>>>
> >>>> (2 + 3) * 5   !=   2 + (3 * 5) // order matters.
> >>>>
> >>>>
> >>> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> >>> irrespective of "where" that simulation is done, at least if H is
> >>> a computation, and if it isn't it can't be a decider.
> >>>
> >>> The CORRECT equivalent to the above would be:
> >>>
> >>> Add(2, 3) * 5 == 5 * Add(2, 3)
> >> You shit for brains fucking idiot! That is not true.
> >>
> >> https://en.wikipedia.org/wiki/Noncommutative_ring
> >>
> >
> > Except both are 5 * 5 so the commutative property isn't needed.
> >
> > You are just being a DICK.
>
> (2 + 3) * 5 == 25 // 2+3== 5 then 5* 5==25
> 2 + (3 * 5) == 17 // 3*5==15 then 2+15==17

On Sun, 4 Sep 2022 05:42:31 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Sunday, 4 September 2022 at 12:56:47 UTC+2, richar...@gmail.com
> wrote:
> > On 9/4/22 3:08 AM, Skep Dick wrote:
> > > On Saturday, 3 September 2022 at 19:24:40 UTC+2,
> > > richar...@gmail.com wrote:
> > >> On 9/3/22 1:18 PM, olcott wrote:
> > >>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> > >>>> On 9/3/22 12:56 PM, olcott wrote:
> > >>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> > >>>>>> On 9/3/22 12:32 PM, olcott wrote:
> > >>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> > >>>>>>>>
> > >>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> > >>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> > >>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> > >>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> > >>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> > >>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> > >>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> > >>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> > >>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> > >>>>>>>>>>>>>>>>>> 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.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> > >>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> > >>>>>>>>>>>>>>>>> understanding these things cannot simply
> > >>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> > >>>>>>>>>>>>>>>>> required to have a basis. This way people are not
> > >>>>>>>>>>>>>>>>> lead astray by a bunch of baseless disagreement,
> > >>>>>>>>>>>>>>>>> they see that the disagreement has no basis and
> > >>>>>>>>>>>>>>>>> reject it.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> > >>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> You just make wild claims based on your own
> > >>>>>>>>>>>>>>>> understanding of the words.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
> > >>>>>>>>>>>>>>>> the words, no one can help you with your logic.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Note, Most of the things you are talking about
> > >>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need to
> > >>>>>>>>>>>>>>>> use that meaning, or you really need to give your
> > >>>>>>>>>>>>>>>> idea a new name (maybe basd on the common name
> > >>>>>>>>>>>>>>>> with a modifier).
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
> > >>>>>>>>>>>>>>>> same as the accepted definition, you can call it
> > >>>>>>>>>>>>>>>> PO-Halting.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> > >>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> > >>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you counter
> > >>>>>>>>>>>>>>>> example doesn't affect the actual Halting Problem,
> > >>>>>>>>>>>>>>>> so it is clear you haven't proven what you claim
> > >>>>>>>>>>>>>>>> to have proven.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> > >>>>>>>>>>>>>>>>>>>> proved that the definition is
> > >>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing that
> > >>>>>>>>>>>>>>>>>>>> proof?
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> You haven't actually given a proof, since you are
> > >>>>>>>>>>>>>>>> clearly using altered definition that you aren't
> > >>>>>>>>>>>>>>>> providing.
> > >>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting
> > >>>>>>>>>>>>>>> with an incorrect basis.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d)
> > >>>>>>>>>>>>>> by DEFINITION gives the exact same result as P(d).
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> When you get a glass of water and dump it on the
> > >>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
> > >>>>>>>>>>>>> wet.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> And I haven't
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> When the correct and complete simulation of the input
> > >>>>>>>>>>>>> by H(P,P) would have different behavior than the
> > >>>>>>>>>>>>> direct execution of P(P) this cannot simply be
> > >>>>>>>>>>>>> ignored.
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> And the correct and complete simulation of the input
> > >>>>>>>>>>>> to H(P,P) Halts.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> > >>>>>>>>>>> never stops running unless H aborts the simulation of
> > >>>>>>>>>>> this input is merely another way of saying that the
> > >>>>>>>>>>> correct and complete simulation of this input by H
> > >>>>>>>>>>> never halts.
> > >>>>>>>>>>
> > >>>>>>>>>> You have bad logic there.
> > >>>>>>>>>
> > >>>>>>>>> It is a tautology:
> > >>>>>>>>>
> > >>>>>>>>> void Infinite_Loop()
> > >>>>>>>>> {
> > >>>>>>>>> HERE: goto HERE;
> > >>>>>>>>> }
> > >>>>>>>>>
> > >>>>>>>>> int main()
> > >>>>>>>>> {
> > >>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> > >>>>>>>>> }
> > >>>>>>>>>
> > >>>>>>>>> _Infinite_Loop()
> > >>>>>>>>> [00001102](01) 55 push ebp
> > >>>>>>>>> [00001103](02) 8bec mov ebp,esp
> > >>>>>>>>> [00001105](02) ebfe jmp 00001105
> > >>>>>>>>> [00001107](01) 5d pop ebp
> > >>>>>>>>> [00001108](01) c3 ret
> > >>>>>>>>> Size in bytes:(0007) [00001108]
> > >>>>>>>>>
> > >>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its
> > >>>>>>>>> input would never stop running unless H0 aborts the
> > >>>>>>>>> simulation of this input is merely another way of saying
> > >>>>>>>>> that the correct and complete simulation of this input by
> > >>>>>>>>> H0 never halts.
> > >>>>>>>>
> > >>>>>>>> Strawman.
> > >>>>>>>>
> > >>>>>>>> Fallacy of Proof by Example.
> > >>>>>>>
> > >>>>>>> It is only a fallacy by proof of example when a single
> > >>>>>>> example is not representative of the entire class of all
> > >>>>>>> such examples.
> > >>>>>>
> > >>>>>> Which it isn't, so FAIL.
> > >>>>>>
> > >>>>>>>
> > >>>>>>> You are confusing existential quantification with universal
> > >>>>>>> quantification.
> > >>>>>>
> > >>>>>> No you are, since you are claiming the rule works for ALL
> > >>>>>> inputs (or at least P, which isn't the input you showed it
> > >>>>>> worked for).
> > >>>>>>>
> > >>>>>>> ∀ simulating halt decider H
> > >>>>>>> ∀ machine description P
> > >>>>>>
> > >>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> > >>>>>>
> > >>>>>> You don't seem to know what those words mean.
> > >>>>>>
> > >>>>>>>
> > >>>>>>> The fact that the correct simulation of any input P to any
> > >>>>>>> simulating halt decider (SHD) H would never stop running
> > >>>>>>> unless this simulation was aborted by this SHD is merely
> > >>>>>>> another way of saying that the correct and complete
> > >>>>>>> simulation of this input by this SHD would never stop
> > >>>>>>> running.
> > >>>>>>
> > >>>>>> Nope, not when the input depends on the behavior of the
> > >>>>>> decider in the way you are doing it.
> > >>>>>
> > >>>>> P was intentionally defined to depend on the behavior of its
> > >>>>> decider *NITWIT*
> > >>>>
> > >>>> Right, but your "example" didn't, and this dependency is the
> > >>>> case that breaks your "proof" and definitions.
> > >>> The correct simulation of the input by H(P,P) is the simulation
> > >>> of this input at the same point in the execution trace where H
> > >>> is invoked.
> > >>>
> > >>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> > >>>
> > >>>
> > >> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> > >> irrespective of "where" that simulation is done, at least if H
> > >> is a computation, and if it isn't it can't be a decider.
> > >>
> > >> The CORRECT equivalent to the above would be:
> > >>
> > >> Add(2, 3) * 5 == 5 * Add(2, 3)
> > > You shit for brains fucking idiot! That is not true.
> > >
> > > https://en.wikipedia.org/wiki/Noncommutative_ring
> > >
> > Except both are 5 * 5 so the commutative property isn't needed.
> >
> > You are just being a DICK.
>
> You shit for brains fucking idiot. It is axiomatic THAT x.y != y.x (1)
>
> let x = Add(2, 3)
> let y = 5
>
> From (1) and by direct substitution ==> Add(2, 3) * 5 != 5 * Add(2, 3)
>
> A scenario in wich x = y is a special case. It requires additional
> steps!
>
> From "x = y", "refl: x ≡ x" and "x.y != y.x" => x.x != x.x =>
>
> NOT(refl: x.x == x.x). HALT.
>
> QED
>
> Do you even understand constructive proofs; or continuity ?!?

On Sun, 4 Sep 2022 05:15:50 -0700 (PDT)
Skep Dick <skepdick22@gmail.com> wrote:

> On Sunday, 4 September 2022 at 12:56:47 UTC+2, richar...@gmail.com
> wrote:
> > On 9/4/22 3:08 AM, Skep Dick wrote:
> > > On Saturday, 3 September 2022 at 19:24:40 UTC+2,
> > > richar...@gmail.com wrote:
> > >> On 9/3/22 1:18 PM, olcott wrote:
> > >>> On 9/3/2022 12:08 PM, Richard Damon wrote:
> > >>>> On 9/3/22 12:56 PM, olcott wrote:
> > >>>>> On 9/3/2022 11:47 AM, Richard Damon wrote:
> > >>>>>> On 9/3/22 12:32 PM, olcott wrote:
> > >>>>>>> On 9/3/2022 11:14 AM, Richard Damon wrote:
> > >>>>>>>>
> > >>>>>>>> On 9/3/22 12:05 PM, olcott wrote:
> > >>>>>>>>> On 9/3/2022 11:00 AM, Richard Damon wrote:
> > >>>>>>>>>> On 9/3/22 11:53 AM, olcott wrote:
> > >>>>>>>>>>> On 9/3/2022 10:31 AM, Richard Damon wrote:
> > >>>>>>>>>>>> On 9/3/22 11:20 AM, olcott wrote:
> > >>>>>>>>>>>>> On 9/3/2022 9:33 AM, Richard Damon wrote:
> > >>>>>>>>>>>>>> On 9/3/22 10:28 AM, olcott wrote:
> > >>>>>>>>>>>>>>> On 9/3/2022 9:26 AM, Richard Damon wrote:
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> On 9/3/22 10:14 AM, olcott wrote:
> > >>>>>>>>>>>>>>>>> On 9/3/2022 9:06 AM, Paul N wrote:
> > >>>>>>>>>>>>>>>>>> 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.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>> When I provide a complete explanation of the
> > >>>>>>>>>>>>>>>>> reasoning behind the answer all those not
> > >>>>>>>>>>>>>>>>> understanding these things cannot simply
> > >>>>>>>>>>>>>>>>> baselessly disagree. All disagreement is thus
> > >>>>>>>>>>>>>>>>> required to have a basis. This way people are not
> > >>>>>>>>>>>>>>>>> lead astray by a bunch of baseless disagreement,
> > >>>>>>>>>>>>>>>>> they see that the disagreement has no basis and
> > >>>>>>>>>>>>>>>>> reject it.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> So, you need to try to actually provide VALID
> > >>>>>>>>>>>>>>>> reasoning, starting from ACCEPTED definition.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> You just make wild claims based on your own
> > >>>>>>>>>>>>>>>> understanding of the words.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Since you don't even attempt to actually DEFINE
> > >>>>>>>>>>>>>>>> the words, no one can help you with your logic.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Note, Most of the things you are talking about
> > >>>>>>>>>>>>>>>> HAVE well defined meanings, so you either need to
> > >>>>>>>>>>>>>>>> use that meaning, or you really need to give your
> > >>>>>>>>>>>>>>>> idea a new name (maybe basd on the common name
> > >>>>>>>>>>>>>>>> with a modifier).
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Thus, if you definition of "Halting" isn't the
> > >>>>>>>>>>>>>>>> same as the accepted definition, you can call it
> > >>>>>>>>>>>>>>>> PO-Halting.
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> Of course the problem with this is it makes it
> > >>>>>>>>>>>>>>>> clear that you are talking about the PO-Halting
> > >>>>>>>>>>>>>>>> Problem, with a PO-Halting Decider, so you counter
> > >>>>>>>>>>>>>>>> example doesn't affect the actual Halting Problem,
> > >>>>>>>>>>>>>>>> so it is clear you haven't proven what you claim
> > >>>>>>>>>>>>>>>> to have proven.
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>>>>> It's not immediately obvious, but it can be
> > >>>>>>>>>>>>>>>>>>>> proved that the definition is
> > >>>>>>>>>>>>>>>>>>>> self-contradictory. You're not disputing that
> > >>>>>>>>>>>>>>>>>>>> proof?
> > >>>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>>> You haven't actually given a proof, since you are
> > >>>>>>>>>>>>>>>> clearly using altered definition that you aren't
> > >>>>>>>>>>>>>>>> providing.
> > >>>>>>>>>>>>>>> You reject the notion of a UTM so you are starting
> > >>>>>>>>>>>>>>> with an incorrect basis.
> > >>>>>>>>>>>>>>>
> > >>>>>>>>>>>>>>
> > >>>>>>>>>>>>>> I have done no such thing. UTM's exist, and UTM(P,d)
> > >>>>>>>>>>>>>> by DEFINITION gives the exact same result as P(d).
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> When you get a glass of water and dump it on the
> > >>>>>>>>>>>>> floor you cannot truthfully deny that the floor is
> > >>>>>>>>>>>>> wet.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> And I haven't
> > >>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>> When the correct and complete simulation of the input
> > >>>>>>>>>>>>> by H(P,P) would have different behavior than the
> > >>>>>>>>>>>>> direct execution of P(P) this cannot simply be
> > >>>>>>>>>>>>> ignored.
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>>
> > >>>>>>>>>>>>
> > >>>>>>>>>>>> And the correct and complete simulation of the input
> > >>>>>>>>>>>> to H(P,P) Halts.
> > >>>>>>>>>>>>
> > >>>>>>>>>>>
> > >>>>>>>>>>> The fact that the simulation by H(P,P) of its input
> > >>>>>>>>>>> never stops running unless H aborts the simulation of
> > >>>>>>>>>>> this input is merely another way of saying that the
> > >>>>>>>>>>> correct and complete simulation of this input by H
> > >>>>>>>>>>> never halts.
> > >>>>>>>>>>
> > >>>>>>>>>> You have bad logic there.
> > >>>>>>>>>
> > >>>>>>>>> It is a tautology:
> > >>>>>>>>>
> > >>>>>>>>> void Infinite_Loop()
> > >>>>>>>>> {
> > >>>>>>>>> HERE: goto HERE;
> > >>>>>>>>> }
> > >>>>>>>>>
> > >>>>>>>>> int main()
> > >>>>>>>>> {
> > >>>>>>>>> Output("Input_Halts = ", H0((u32)Infinite_Loop));
> > >>>>>>>>> }
> > >>>>>>>>>
> > >>>>>>>>> _Infinite_Loop()
> > >>>>>>>>> [00001102](01) 55 push ebp
> > >>>>>>>>> [00001103](02) 8bec mov ebp,esp
> > >>>>>>>>> [00001105](02) ebfe jmp 00001105
> > >>>>>>>>> [00001107](01) 5d pop ebp
> > >>>>>>>>> [00001108](01) c3 ret
> > >>>>>>>>> Size in bytes:(0007) [00001108]
> > >>>>>>>>>
> > >>>>>>>>> The fact that the simulation by H0(Infinite_Loop) of its
> > >>>>>>>>> input would never stop running unless H0 aborts the
> > >>>>>>>>> simulation of this input is merely another way of saying
> > >>>>>>>>> that the correct and complete simulation of this input by
> > >>>>>>>>> H0 never halts.
> > >>>>>>>>
> > >>>>>>>> Strawman.
> > >>>>>>>>
> > >>>>>>>> Fallacy of Proof by Example.
> > >>>>>>>
> > >>>>>>> It is only a fallacy by proof of example when a single
> > >>>>>>> example is not representative of the entire class of all
> > >>>>>>> such examples.
> > >>>>>>
> > >>>>>> Which it isn't, so FAIL.
> > >>>>>>
> > >>>>>>>
> > >>>>>>> You are confusing existential quantification with universal
> > >>>>>>> quantification.
> > >>>>>>
> > >>>>>> No you are, since you are claiming the rule works for ALL
> > >>>>>> inputs (or at least P, which isn't the input you showed it
> > >>>>>> worked for).
> > >>>>>>>
> > >>>>>>> ∀ simulating halt decider H
> > >>>>>>> ∀ machine description P
> > >>>>>>
> > >>>>>> Right. ∀, so UNIVERSAL, not EXISTENTIAL, so FAIL.
> > >>>>>>
> > >>>>>> You don't seem to know what those words mean.
> > >>>>>>
> > >>>>>>>
> > >>>>>>> The fact that the correct simulation of any input P to any
> > >>>>>>> simulating halt decider (SHD) H would never stop running
> > >>>>>>> unless this simulation was aborted by this SHD is merely
> > >>>>>>> another way of saying that the correct and complete
> > >>>>>>> simulation of this input by this SHD would never stop
> > >>>>>>> running.
> > >>>>>>
> > >>>>>> Nope, not when the input depends on the behavior of the
> > >>>>>> decider in the way you are doing it.
> > >>>>>
> > >>>>> P was intentionally defined to depend on the behavior of its
> > >>>>> decider *NITWIT*
> > >>>>
> > >>>> Right, but your "example" didn't, and this dependency is the
> > >>>> case that breaks your "proof" and definitions.
> > >>> The correct simulation of the input by H(P,P) is the simulation
> > >>> of this input at the same point in the execution trace where H
> > >>> is invoked.
> > >>>
> > >>> (2 + 3) * 5 != 2 + (3 * 5) // order matters.
> > >>>
> > >>>
> > >> Red Herring. Simulate(P,P) is ALWAYS the same (for a given P)
> > >> irrespective of "where" that simulation is done, at least if H
> > >> is a computation, and if it isn't it can't be a decider.
> > >>
> > >> The CORRECT equivalent to the above would be:
> > >>
> > >> Add(2, 3) * 5 == 5 * Add(2, 3)
> > > You shit for brains fucking idiot! That is not true.
> > >
> > > https://en.wikipedia.org/wiki/Noncommutative_ring
> > >
> > Except both are 5 * 5 so the commutative property isn't needed.
> >
> > You are just being a DICK.
> You shit for brains fucking idiot. It is axiomatic THAT x.y != y.x
> (1)
>
> let x = Add(2, 3)
> let y = 5
>
> From (1) and by direct substitution ==> Add(2, 3) * 5 != 5 * Add(2, 3)
>
> A scenario in wich x = y is a special case. It requires additional
> steps!
>
> From "x = y" and "x.y = y.x" => x.x = x.x
>
> refl: x.x == x.x
>
> QED
>
> Do you even understand constructive proofs; or continuity ?!?

Skep Dick <skepdick22@gmail.com> writes:
<typical snipped attributions>

>> > https://en.wikipedia.org/wiki/Noncommutative_ring
>> >
>> Except both are 5 * 5 so the commutative property isn't needed.
>>
>> You are just being a DICK.
>
> You shit for brains fucking idiot. It is axiomatic THAT x.y != y.x

(a) No. As stated, x.y != y.x is never an axiom. Some authors don't
want commutative rings to be a subset of non-commutative rings so
they /do/ have a similar looking axiom, but it's "for x != y".

(b) The binary . operation is a function from SxS to S. There is only
one element (5, 5) in the domain of f.

> A scenario in wich x = y is a special case. It requires additional
> steps!

No, because x.y != y.x (without qualification) isn't an axiom. That
.. is commutative with equal operands follows from what a function is.

> Do you even understand constructive proofs; or continuity ?!?

Good trolling. Drop a few big words and see if anyone bites those as
well.

--
Ben.