On 9/4/2022 1:07 PM, Richard Damon wrote:
> On 9/4/22 1:50 PM, olcott wrote:
>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>
>>> On 9/4/22 12:33 PM, olcott wrote:
>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>
>>>> Although H must be a computation all sequences of configurations
>>>> that do not halt are not computations**. The behavior of H is the
>>>> same no matter where it is invoked.
>>>>
>>>
>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time, by
>>> the H you claim to be correct.
>>>
>>>> The behavior of P need not be (and indeed is not) the same. When P
>>>> is invoked from main its behavior depends on the return value of H.
>>>> When P is correctly simulated by H the return value from H is
>>>> unreachable from every simulated P. This conclusively proves that
>>>> the execution of P from main() and the correct simulation of P by H
>>>> are not computationally equivalent.
>>>
>>>
>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>
>> All of your rebuttals are simply false assumptions and nothing more.
>> I claim that
>>
>>     "When P is correctly simulated by H the return value from
>>      H is unreachable from every simulated P."
>
> SO? There is no requirement that H is able to see the resuts of the call
> inside the input it is simulating.
>
> The ACTUAL behavior of the input to H(P,P) is DEFINED as the behavior of
> P(P) or Simulate(P,P). The fact that H can't determine that is H's fault.
>
> Do you disagree that the CORRECT answer is based on the ACTUAL BEHAVIOR
> of the ACUTAL INPUT?
>
> H's inability to determine that is WHY it gets the wrong answer, not an
> excuse for it to do so.
>
>>
>> When you claim that I am incorrect it is merely an empty assertion
>> utterly bereft of supporting reasoning.
>
> No, you LITERALLY are making an empty assertion, as you are asserting
> something that never occurs.
>
> There is NO H that does a complete and correct simulation and returns an
> answer. We can even argue that it doesn't do a correct simulation since
> the last step of the simulation has an error as it presumes the wrong
> behavior of the call to H that it encounter (you can debate if this is
> an incorrect simulation or just unsound logic).
>
>>
>> A simulating halt decider continues to simulate its input until it
>> correctly matches a correct infinite behavior pattern.
>
> Then why does you H abort too soon, as shown by the fact that the
> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>
> Just says that your H doesn't even meet your own definition.
>
>>
>> void Px(ptr x)
>> {
>>    int Halt_Status = Hx(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return;
>> }
>>
>> int main()
>> {
>>    Output("Input_Halts = ", Hx(Px, Px));
>> }
>>
>> In order for me to actually be wrong you must be able to show that
>> some simulating halt decider Hx could be defined such that its correct
>> simulation of its input Px reaches the final state of Px in a finite
>> number of steps.
>>
>
> Nope. H(P,P) is wrong

On 9/4/22 2:35 PM, olcott wrote:
> On 9/4/2022 1:07 PM, Richard Damon wrote:
>> On 9/4/22 1:50 PM, olcott wrote:
>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>
>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>
>>>>> Although H must be a computation all sequences of configurations
>>>>> that do not halt are not computations**. The behavior of H is the
>>>>> same no matter where it is invoked.
>>>>>
>>>>
>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time, by
>>>> the H you claim to be correct.
>>>>
>>>>> The behavior of P need not be (and indeed is not) the same. When P
>>>>> is invoked from main its behavior depends on the return value of H.
>>>>> When P is correctly simulated by H the return value from H is
>>>>> unreachable from every simulated P. This conclusively proves that
>>>>> the execution of P from main() and the correct simulation of P by H
>>>>> are not computationally equivalent.
>>>>
>>>>
>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>
>>> All of your rebuttals are simply false assumptions and nothing more.
>>> I claim that
>>>
>>>     "When P is correctly simulated by H the return value from
>>>      H is unreachable from every simulated P."
>>
>> SO? There is no requirement that H is able to see the resuts of the
>> call inside the input it is simulating.
>>
>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the behavior
>> of P(P) or Simulate(P,P). The fact that H can't determine that is H's
>> fault.
>>
>> Do you disagree that the CORRECT answer is based on the ACTUAL
>> BEHAVIOR of the ACUTAL INPUT?
>>
>> H's inability to determine that is WHY it gets the wrong answer, not
>> an excuse for it to do so.
>>
>>>
>>> When you claim that I am incorrect it is merely an empty assertion
>>> utterly bereft of supporting reasoning.
>>
>> No, you LITERALLY are making an empty assertion, as you are asserting
>> something that never occurs.
>>
>> There is NO H that does a complete and correct simulation and returns
>> an answer. We can even argue that it doesn't do a correct simulation
>> since the last step of the simulation has an error as it presumes the
>> wrong behavior of the call to H that it encounter (you can debate if
>> this is an incorrect simulation or just unsound logic).
>>
>>>
>>> A simulating halt decider continues to simulate its input until it
>>> correctly matches a correct infinite behavior pattern.
>>
>> Then why does you H abort too soon, as shown by the fact that the
>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>
>> Just says that your H doesn't even meet your own definition.
>>
>>>
>>> void Px(ptr x)
>>> {
>>>    int Halt_Status = Hx(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return;
>>> }
>>>
>>> int main()
>>> {
>>>    Output("Input_Halts = ", Hx(Px, Px));
>>> }
>>>
>>> In order for me to actually be wrong you must be able to show that
>>> some simulating halt decider Hx could be defined such that its
>>> correct simulation of its input Px reaches the final state of Px in a
>>> finite number of steps.
>>>
>>
>> Nope. H(P,P) is wrong
>
> ..then a mistake could be shown, if no mistake can be shown then it is
> not wrong.

On 9/4/2022 2:04 PM, Richard Damon wrote:
> On 9/4/22 2:35 PM, olcott wrote:
>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>> On 9/4/22 1:50 PM, olcott wrote:
>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>
>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>>
>>>>>> Although H must be a computation all sequences of configurations
>>>>>> that do not halt are not computations**. The behavior of H is the
>>>>>> same no matter where it is invoked.
>>>>>>
>>>>>
>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time, by
>>>>> the H you claim to be correct.
>>>>>
>>>>>> The behavior of P need not be (and indeed is not) the same. When P
>>>>>> is invoked from main its behavior depends on the return value of
>>>>>> H. When P is correctly simulated by H the return value from H is
>>>>>> unreachable from every simulated P. This conclusively proves that
>>>>>> the execution of P from main() and the correct simulation of P by
>>>>>> H are not computationally equivalent.
>>>>>
>>>>>
>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>
>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>> I claim that
>>>>
>>>>     "When P is correctly simulated by H the return value from
>>>>      H is unreachable from every simulated P."
>>>
>>> SO? There is no requirement that H is able to see the resuts of the
>>> call inside the input it is simulating.
>>>
>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the behavior
>>> of P(P) or Simulate(P,P). The fact that H can't determine that is H's
>>> fault.
>>>
>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>> BEHAVIOR of the ACUTAL INPUT?
>>>
>>> H's inability to determine that is WHY it gets the wrong answer, not
>>> an excuse for it to do so.
>>>
>>>>
>>>> When you claim that I am incorrect it is merely an empty assertion
>>>> utterly bereft of supporting reasoning.
>>>
>>> No, you LITERALLY are making an empty assertion, as you are asserting
>>> something that never occurs.
>>>
>>> There is NO H that does a complete and correct simulation and returns
>>> an answer. We can even argue that it doesn't do a correct simulation
>>> since the last step of the simulation has an error as it presumes the
>>> wrong behavior of the call to H that it encounter (you can debate if
>>> this is an incorrect simulation or just unsound logic).
>>>
>>>>
>>>> A simulating halt decider continues to simulate its input until it
>>>> correctly matches a correct infinite behavior pattern.
>>>
>>> Then why does you H abort too soon, as shown by the fact that the
>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>
>>> Just says that your H doesn't even meet your own definition.
>>>
>>>>
>>>> void Px(ptr x)
>>>> {
>>>>    int Halt_Status = Hx(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    Output("Input_Halts = ", Hx(Px, Px));
>>>> }
>>>>
>>>> In order for me to actually be wrong you must be able to show that
>>>> some simulating halt decider Hx could be defined such that its
>>>> correct simulation of its input Px reaches the final state of Px in
>>>> a finite number of steps.
>>>>
>>>
>>> Nope. H(P,P) is wrong
>>
>> ..then a mistake could be shown, if no mistake can be shown then it is
>> not wrong.
>
> And it has been.
>
> Even YOU hav published the correct and complete simuliaton of the input
> to H(P,P) being the trace of P(P) and Simulate(P,P)
>
>>
>> I contend that that no simulating halt decider Hx can be defined such
>> that its correctly simulated input Px could reach the final state of
>> this simulated Px in any finite number of steps.
>
> So, that isn't the question.

On 9/4/22 3:16 PM, olcott wrote:
> On 9/4/2022 2:04 PM, Richard Damon wrote:
>> On 9/4/22 2:35 PM, olcott wrote:
>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>
>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>>>
>>>>>>> Although H must be a computation all sequences of configurations
>>>>>>> that do not halt are not computations**. The behavior of H is the
>>>>>>> same no matter where it is invoked.
>>>>>>>
>>>>>>
>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>> by the H you claim to be correct.
>>>>>>
>>>>>>> The behavior of P need not be (and indeed is not) the same. When
>>>>>>> P is invoked from main its behavior depends on the return value
>>>>>>> of H. When P is correctly simulated by H the return value from H
>>>>>>> is unreachable from every simulated P. This conclusively proves
>>>>>>> that the execution of P from main() and the correct simulation of
>>>>>>> P by H are not computationally equivalent.
>>>>>>
>>>>>>
>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>
>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>> I claim that
>>>>>
>>>>>     "When P is correctly simulated by H the return value from
>>>>>      H is unreachable from every simulated P."
>>>>
>>>> SO? There is no requirement that H is able to see the resuts of the
>>>> call inside the input it is simulating.
>>>>
>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>> that is H's fault.
>>>>
>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>
>>>> H's inability to determine that is WHY it gets the wrong answer, not
>>>> an excuse for it to do so.
>>>>
>>>>>
>>>>> When you claim that I am incorrect it is merely an empty assertion
>>>>> utterly bereft of supporting reasoning.
>>>>
>>>> No, you LITERALLY are making an empty assertion, as you are
>>>> asserting something that never occurs.
>>>>
>>>> There is NO H that does a complete and correct simulation and
>>>> returns an answer. We can even argue that it doesn't do a correct
>>>> simulation since the last step of the simulation has an error as it
>>>> presumes the wrong behavior of the call to H that it encounter (you
>>>> can debate if this is an incorrect simulation or just unsound logic).
>>>>
>>>>>
>>>>> A simulating halt decider continues to simulate its input until it
>>>>> correctly matches a correct infinite behavior pattern.
>>>>
>>>> Then why does you H abort too soon, as shown by the fact that the
>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>
>>>> Just says that your H doesn't even meet your own definition.
>>>>
>>>>>
>>>>> void Px(ptr x)
>>>>> {
>>>>>    int Halt_Status = Hx(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    Output("Input_Halts = ", Hx(Px, Px));
>>>>> }
>>>>>
>>>>> In order for me to actually be wrong you must be able to show that
>>>>> some simulating halt decider Hx could be defined such that its
>>>>> correct simulation of its input Px reaches the final state of Px in
>>>>> a finite number of steps.
>>>>>
>>>>
>>>> Nope. H(P,P) is wrong
>>>
>>> ..then a mistake could be shown, if no mistake can be shown then it
>>> is not wrong.
>>
>> And it has been.
>>
>> Even YOU hav published the correct and complete simuliaton of the
>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>
>>>
>>> I contend that that no simulating halt decider Hx can be defined such
>>> that its correctly simulated input Px could reach the final state of
>>> this simulated Px in any finite number of steps.
>>
>> So, that isn't the question.
>
> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>
> Any rebuttal must show all of the steps of exactly how the input to
> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in a
> finite number of steps.
>
> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>
>

On 9/4/2022 2:21 PM, Richard Damon wrote:
> On 9/4/22 3:16 PM, olcott wrote:
>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>> On 9/4/22 2:35 PM, olcott wrote:
>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>>>>
>>>>>>>> Although H must be a computation all sequences of configurations
>>>>>>>> that do not halt are not computations**. The behavior of H is
>>>>>>>> the same no matter where it is invoked.
>>>>>>>>
>>>>>>>
>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>> by the H you claim to be correct.
>>>>>>>
>>>>>>>> The behavior of P need not be (and indeed is not) the same. When
>>>>>>>> P is invoked from main its behavior depends on the return value
>>>>>>>> of H. When P is correctly simulated by H the return value from H
>>>>>>>> is unreachable from every simulated P. This conclusively proves
>>>>>>>> that the execution of P from main() and the correct simulation
>>>>>>>> of P by H are not computationally equivalent.
>>>>>>>
>>>>>>>
>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>
>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>> I claim that
>>>>>>
>>>>>>     "When P is correctly simulated by H the return value from
>>>>>>      H is unreachable from every simulated P."
>>>>>
>>>>> SO? There is no requirement that H is able to see the resuts of the
>>>>> call inside the input it is simulating.
>>>>>
>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>> that is H's fault.
>>>>>
>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>
>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>> not an excuse for it to do so.
>>>>>
>>>>>>
>>>>>> When you claim that I am incorrect it is merely an empty assertion
>>>>>> utterly bereft of supporting reasoning.
>>>>>
>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>> asserting something that never occurs.
>>>>>
>>>>> There is NO H that does a complete and correct simulation and
>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>> simulation since the last step of the simulation has an error as it
>>>>> presumes the wrong behavior of the call to H that it encounter (you
>>>>> can debate if this is an incorrect simulation or just unsound logic).
>>>>>
>>>>>>
>>>>>> A simulating halt decider continues to simulate its input until it
>>>>>> correctly matches a correct infinite behavior pattern.
>>>>>
>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>
>>>>> Just says that your H doesn't even meet your own definition.
>>>>>
>>>>>>
>>>>>> void Px(ptr x)
>>>>>> {
>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    Output("Input_Halts = ", Hx(Px, Px));
>>>>>> }
>>>>>>
>>>>>> In order for me to actually be wrong you must be able to show that
>>>>>> some simulating halt decider Hx could be defined such that its
>>>>>> correct simulation of its input Px reaches the final state of Px
>>>>>> in a finite number of steps.
>>>>>>
>>>>>
>>>>> Nope. H(P,P) is wrong
>>>>
>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>> is not wrong.
>>>
>>> And it has been.
>>>
>>> Even YOU hav published the correct and complete simuliaton of the
>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>
>>>>
>>>> I contend that that no simulating halt decider Hx can be defined
>>>> such that its correctly simulated input Px could reach the final
>>>> state of this simulated Px in any finite number of steps.
>>>
>>> So, that isn't the question.
>>
>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>
>> Any rebuttal must show all of the steps of exactly how the input to
>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in a
>> finite number of steps.
>>
>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>
>>
>
> You don't get to stipulate the test,

On Sunday, 4 September 2022 at 17:35:08 UTC+2, Ben Bacarisse wrote:
> Skep Dick <skepd...@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".

Which is the exact same thing. You are tripping up over syntax (as usual).

Let x = p.q
Let y = q.p

x != y ==> p.q != q.p (direct substitution)

> (b) The binary . operation is a function from SxS to S. There is only
> one element (5, 5) in the domain of f.
Which is precisely why it is a special case.

> > 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.
Bullshit! I am literally expressing a substitution rule.

The expression x.y is NOT substitutable for the expression y.x
> . 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.
Yes. It is probably because I am “trolling” is why you refuse to answer whether subsets of finite sets are always finite.

On Sunday, 4 September 2022 at 18:44:17 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 8:15 AM, Skep Dick 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)
>
> You axioms seem to be wrong.
>
> Non commutative rings say that x.y MIGHT NOT EQUAL to y.x, not that they
> ARE different.
So they might be equal, or they might be NOT equal!

On 9/4/22 3:30 PM, olcott wrote:
> On 9/4/2022 2:21 PM, Richard Damon wrote:
>> On 9/4/22 3:16 PM, olcott wrote:
>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>
>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>>>>>
>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>> by the H you claim to be correct.
>>>>>>>>
>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>
>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>> I claim that
>>>>>>>
>>>>>>>     "When P is correctly simulated by H the return value from
>>>>>>>      H is unreachable from every simulated P."
>>>>>>
>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>> the call inside the input it is simulating.
>>>>>>
>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>> that is H's fault.
>>>>>>
>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>
>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>> not an excuse for it to do so.
>>>>>>
>>>>>>>
>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>
>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>> asserting something that never occurs.
>>>>>>
>>>>>> There is NO H that does a complete and correct simulation and
>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>> simulation since the last step of the simulation has an error as
>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>> logic).
>>>>>>
>>>>>>>
>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>
>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>
>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>
>>>>>>>
>>>>>>> void Px(ptr x)
>>>>>>> {
>>>>>>>    int Halt_Status = Hx(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    Output("Input_Halts = ", Hx(Px, Px));
>>>>>>> }
>>>>>>>
>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>> Px in a finite number of steps.
>>>>>>>
>>>>>>
>>>>>> Nope. H(P,P) is wrong
>>>>>
>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>> is not wrong.
>>>>
>>>> And it has been.
>>>>
>>>> Even YOU hav published the correct and complete simuliaton of the
>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>
>>>>>
>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>> such that its correctly simulated input Px could reach the final
>>>>> state of this simulated Px in any finite number of steps.
>>>>
>>>> So, that isn't the question.
>>>
>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>
>>> Any rebuttal must show all of the steps of exactly how the input to
>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>> a finite number of steps.
>>>
>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>
>>>
>>
>> You don't get to stipulate the test,
>
> In other words you know that my statement is correct and you are too
> dishonest to admit it.
>

On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 3:30 PM, olcott wrote:
> > On 9/4/2022 2:21 PM, Richard Damon wrote:
> >> On 9/4/22 3:16 PM, olcott wrote:
> >>> On 9/4/2022 2:04 PM, Richard Damon wrote:
> >>>> On 9/4/22 2:35 PM, olcott wrote:
> >>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
> >>>>>> On 9/4/22 1:50 PM, olcott wrote:
> >>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
> >>>>>>>>
> >>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
> >>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
> >>>>>>>>>>
> >>>>>>>>> Although H must be a computation all sequences of
> >>>>>>>>> configurations that do not halt are not computations**. The
> >>>>>>>>> behavior of H is the same no matter where it is invoked.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
> >>>>>>>> by the H you claim to be correct.
> >>>>>>>>
> >>>>>>>>> The behavior of P need not be (and indeed is not) the same.
> >>>>>>>>> When P is invoked from main its behavior depends on the return
> >>>>>>>>> value of H. When P is correctly simulated by H the return value
> >>>>>>>>> from H is unreachable from every simulated P. This conclusively
> >>>>>>>>> proves that the execution of P from main() and the correct
> >>>>>>>>> simulation of P by H are not computationally equivalent.
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
> >>>>>>>>
> >>>>>>> All of your rebuttals are simply false assumptions and nothing more.
> >>>>>>> I claim that
> >>>>>>>
> >>>>>>> "When P is correctly simulated by H the return value from
> >>>>>>> H is unreachable from every simulated P."
> >>>>>>
> >>>>>> SO? There is no requirement that H is able to see the resuts of
> >>>>>> the call inside the input it is simulating.
> >>>>>>
> >>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
> >>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
> >>>>>> that is H's fault.
> >>>>>>
> >>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
> >>>>>> BEHAVIOR of the ACUTAL INPUT?
> >>>>>>
> >>>>>> H's inability to determine that is WHY it gets the wrong answer,
> >>>>>> not an excuse for it to do so.
> >>>>>>
> >>>>>>>
> >>>>>>> When you claim that I am incorrect it is merely an empty
> >>>>>>> assertion utterly bereft of supporting reasoning.
> >>>>>>
> >>>>>> No, you LITERALLY are making an empty assertion, as you are
> >>>>>> asserting something that never occurs.
> >>>>>>
> >>>>>> There is NO H that does a complete and correct simulation and
> >>>>>> returns an answer. We can even argue that it doesn't do a correct
> >>>>>> simulation since the last step of the simulation has an error as
> >>>>>> it presumes the wrong behavior of the call to H that it encounter
> >>>>>> (you can debate if this is an incorrect simulation or just unsound
> >>>>>> logic).
> >>>>>>
> >>>>>>>
> >>>>>>> A simulating halt decider continues to simulate its input until
> >>>>>>> it correctly matches a correct infinite behavior pattern.
> >>>>>>
> >>>>>> Then why does you H abort too soon, as shown by the fact that the
> >>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
> >>>>>>
> >>>>>> Just says that your H doesn't even meet your own definition.
> >>>>>>
> >>>>>>>
> >>>>>>> void Px(ptr x)
> >>>>>>> {
> >>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>> if (Halt_Status)
> >>>>>>> HERE: goto HERE;
> >>>>>>> return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>> }
> >>>>>>>
> >>>>>>> In order for me to actually be wrong you must be able to show
> >>>>>>> that some simulating halt decider Hx could be defined such that
> >>>>>>> its correct simulation of its input Px reaches the final state of
> >>>>>>> Px in a finite number of steps.
> >>>>>>>
> >>>>>>
> >>>>>> Nope. H(P,P) is wrong
> >>>>>
> >>>>> ..then a mistake could be shown, if no mistake can be shown then it
> >>>>> is not wrong.
> >>>>
> >>>> And it has been.
> >>>>
> >>>> Even YOU hav published the correct and complete simuliaton of the
> >>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
> >>>>
> >>>>>
> >>>>> I contend that that no simulating halt decider Hx can be defined
> >>>>> such that its correctly simulated input Px could reach the final
> >>>>> state of this simulated Px in any finite number of steps.
> >>>>
> >>>> So, that isn't the question.
> >>>
> >>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
> >>>
> >>> Any rebuttal must show all of the steps of exactly how the input to
> >>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
> >>> a finite number of steps.
> >>>
> >>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
> >>>
> >>>
> >>
> >> You don't get to stipulate the test,
> >
> > In other words you know that my statement is correct and you are too
> > dishonest to admit it.
> >
> Nope, shows you don't understand about requirements.
>
> Would you tell a police officer that pulled you over for doing 40 in a
> 25 zone, that you know better then him what the rules of the road are?
False analogy.

On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
> On 9/4/22 3:30 PM, olcott wrote:
> > On 9/4/2022 2:21 PM, Richard Damon wrote:
> >> On 9/4/22 3:16 PM, olcott wrote:
> >>> On 9/4/2022 2:04 PM, Richard Damon wrote:
> >>>> On 9/4/22 2:35 PM, olcott wrote:
> >>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
> >>>>>> On 9/4/22 1:50 PM, olcott wrote:
> >>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
> >>>>>>>>
> >>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
> >>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
> >>>>>>>>>>
> >>>>>>>>> Although H must be a computation all sequences of
> >>>>>>>>> configurations that do not halt are not computations**. The
> >>>>>>>>> behavior of H is the same no matter where it is invoked.
> >>>>>>>>>
> >>>>>>>>
> >>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
> >>>>>>>> by the H you claim to be correct.
> >>>>>>>>
> >>>>>>>>> The behavior of P need not be (and indeed is not) the same.
> >>>>>>>>> When P is invoked from main its behavior depends on the return
> >>>>>>>>> value of H. When P is correctly simulated by H the return value
> >>>>>>>>> from H is unreachable from every simulated P. This conclusively
> >>>>>>>>> proves that the execution of P from main() and the correct
> >>>>>>>>> simulation of P by H are not computationally equivalent.
> >>>>>>>>
> >>>>>>>>
> >>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
> >>>>>>>>
> >>>>>>> All of your rebuttals are simply false assumptions and nothing more.
> >>>>>>> I claim that
> >>>>>>>
> >>>>>>> "When P is correctly simulated by H the return value from
> >>>>>>> H is unreachable from every simulated P."
> >>>>>>
> >>>>>> SO? There is no requirement that H is able to see the resuts of
> >>>>>> the call inside the input it is simulating.
> >>>>>>
> >>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
> >>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
> >>>>>> that is H's fault.
> >>>>>>
> >>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
> >>>>>> BEHAVIOR of the ACUTAL INPUT?
> >>>>>>
> >>>>>> H's inability to determine that is WHY it gets the wrong answer,
> >>>>>> not an excuse for it to do so.
> >>>>>>
> >>>>>>>
> >>>>>>> When you claim that I am incorrect it is merely an empty
> >>>>>>> assertion utterly bereft of supporting reasoning.
> >>>>>>
> >>>>>> No, you LITERALLY are making an empty assertion, as you are
> >>>>>> asserting something that never occurs.
> >>>>>>
> >>>>>> There is NO H that does a complete and correct simulation and
> >>>>>> returns an answer. We can even argue that it doesn't do a correct
> >>>>>> simulation since the last step of the simulation has an error as
> >>>>>> it presumes the wrong behavior of the call to H that it encounter
> >>>>>> (you can debate if this is an incorrect simulation or just unsound
> >>>>>> logic).
> >>>>>>
> >>>>>>>
> >>>>>>> A simulating halt decider continues to simulate its input until
> >>>>>>> it correctly matches a correct infinite behavior pattern.
> >>>>>>
> >>>>>> Then why does you H abort too soon, as shown by the fact that the
> >>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
> >>>>>>
> >>>>>> Just says that your H doesn't even meet your own definition.
> >>>>>>
> >>>>>>>
> >>>>>>> void Px(ptr x)
> >>>>>>> {
> >>>>>>> int Halt_Status = Hx(x, x);
> >>>>>>> if (Halt_Status)
> >>>>>>> HERE: goto HERE;
> >>>>>>> return;
> >>>>>>> }
> >>>>>>>
> >>>>>>> int main()
> >>>>>>> {
> >>>>>>> Output("Input_Halts = ", Hx(Px, Px));
> >>>>>>> }
> >>>>>>>
> >>>>>>> In order for me to actually be wrong you must be able to show
> >>>>>>> that some simulating halt decider Hx could be defined such that
> >>>>>>> its correct simulation of its input Px reaches the final state of
> >>>>>>> Px in a finite number of steps.
> >>>>>>>
> >>>>>>
> >>>>>> Nope. H(P,P) is wrong
> >>>>>
> >>>>> ..then a mistake could be shown, if no mistake can be shown then it
> >>>>> is not wrong.
> >>>>
> >>>> And it has been.
> >>>>
> >>>> Even YOU hav published the correct and complete simuliaton of the
> >>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
> >>>>
> >>>>>
> >>>>> I contend that that no simulating halt decider Hx can be defined
> >>>>> such that its correctly simulated input Px could reach the final
> >>>>> state of this simulated Px in any finite number of steps.
> >>>>
> >>>> So, that isn't the question.
> >>>
> >>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
> >>>
> >>> Any rebuttal must show all of the steps of exactly how the input to
> >>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
> >>> a finite number of steps.
> >>>
> >>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
> >>>
> >>>
> >>
> >> You don't get to stipulate the test,
> >
> > In other words you know that my statement is correct and you are too
> > dishonest to admit it.
> >
> Nope, shows you don't understand about requirements.
Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.

On 9/4/22 3:52 PM, Skep Dick wrote:
> On Sunday, 4 September 2022 at 18:44:17 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 8:15 AM, Skep Dick 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)
>>
>> You axioms seem to be wrong.
>>
>> Non commutative rings say that x.y MIGHT NOT EQUAL to y.x, not that they
>> ARE different.
> So they might be equal, or they might be NOT equal!
>
> Provide a continuous function deciding one of the other.
>
> Provide a proof.

On 9/4/22 3:57 PM, Skep Dick wrote:
> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 3:30 PM, olcott wrote:
>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
>>>> On 9/4/22 3:16 PM, olcott wrote:
>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>>>>>>>
>>>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>>>> by the H you claim to be correct.
>>>>>>>>>>
>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>>>
>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>>>> I claim that
>>>>>>>>>
>>>>>>>>> "When P is correctly simulated by H the return value from
>>>>>>>>> H is unreachable from every simulated P."
>>>>>>>>
>>>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>>>> the call inside the input it is simulating.
>>>>>>>>
>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>>>> that is H's fault.
>>>>>>>>
>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>>>
>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>>>> not an excuse for it to do so.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>>>
>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>>>> asserting something that never occurs.
>>>>>>>>
>>>>>>>> There is NO H that does a complete and correct simulation and
>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>>>> simulation since the last step of the simulation has an error as
>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>>>> logic).
>>>>>>>>
>>>>>>>>>
>>>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>>>
>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>>>
>>>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> void Px(ptr x)
>>>>>>>>> {
>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>>>> Px in a finite number of steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope. H(P,P) is wrong
>>>>>>>
>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>>>> is not wrong.
>>>>>>
>>>>>> And it has been.
>>>>>>
>>>>>> Even YOU hav published the correct and complete simuliaton of the
>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>>>
>>>>>>>
>>>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>>>> such that its correctly simulated input Px could reach the final
>>>>>>> state of this simulated Px in any finite number of steps.
>>>>>>
>>>>>> So, that isn't the question.
>>>>>
>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>>>
>>>>> Any rebuttal must show all of the steps of exactly how the input to
>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>>>> a finite number of steps.
>>>>>
>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>>>
>>>>>
>>>>
>>>> You don't get to stipulate the test,
>>>
>>> In other words you know that my statement is correct and you are too
>>> dishonest to admit it.
>>>
>> Nope, shows you don't understand about requirements.
>>
>> Would you tell a police officer that pulled you over for doing 40 in a
>> 25 zone, that you know better then him what the rules of the road are?
> False analogy.
>
> In my system I am the law.
>
>> Remember, if H is a Halt Decider, it is DEFINED that H(P,d) will return
>> 1 if P(d) Halts, and 0 of P(d) Never Hats.
>
>> Since P(P) Halts if H(P,P) returns 0
> How have you determined the halting or non-halting behavior of P(P) ?

On 9/4/22 4:01 PM, Skep Dick wrote:
> On Sunday, 4 September 2022 at 21:52:16 UTC+2, richar...@gmail.com wrote:
>> On 9/4/22 3:30 PM, olcott wrote:
>>> On 9/4/2022 2:21 PM, Richard Damon wrote:
>>>> On 9/4/22 3:16 PM, olcott wrote:
>>>>> On 9/4/2022 2:04 PM, Richard Damon wrote:
>>>>>> On 9/4/22 2:35 PM, olcott wrote:
>>>>>>> On 9/4/2022 1:07 PM, Richard Damon wrote:
>>>>>>>> On 9/4/22 1:50 PM, olcott wrote:
>>>>>>>>> On 9/4/2022 12:14 PM, Richard Damon wrote:
>>>>>>>>>>
>>>>>>>>>> On 9/4/22 12:33 PM, olcott wrote:
>>>>>>>>>>> On 9/3/2022 12:24 PM, Richard Damon 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.
>>>>>>>>>>>>
>>>>>>>>>>> Although H must be a computation all sequences of
>>>>>>>>>>> configurations that do not halt are not computations**. The
>>>>>>>>>>> behavior of H is the same no matter where it is invoked.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, so H(P,P) is ALWAYS the same, to return a 0 in finite time,
>>>>>>>>>> by the H you claim to be correct.
>>>>>>>>>>
>>>>>>>>>>> The behavior of P need not be (and indeed is not) the same.
>>>>>>>>>>> When P is invoked from main its behavior depends on the return
>>>>>>>>>>> value of H. When P is correctly simulated by H the return value
>>>>>>>>>>> from H is unreachable from every simulated P. This conclusively
>>>>>>>>>>> proves that the execution of P from main() and the correct
>>>>>>>>>>> simulation of P by H are not computationally equivalent.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope, by the construction of P, P will ALWAYS behave the same.
>>>>>>>>>>
>>>>>>>>> All of your rebuttals are simply false assumptions and nothing more.
>>>>>>>>> I claim that
>>>>>>>>>
>>>>>>>>> "When P is correctly simulated by H the return value from
>>>>>>>>> H is unreachable from every simulated P."
>>>>>>>>
>>>>>>>> SO? There is no requirement that H is able to see the resuts of
>>>>>>>> the call inside the input it is simulating.
>>>>>>>>
>>>>>>>> The ACTUAL behavior of the input to H(P,P) is DEFINED as the
>>>>>>>> behavior of P(P) or Simulate(P,P). The fact that H can't determine
>>>>>>>> that is H's fault.
>>>>>>>>
>>>>>>>> Do you disagree that the CORRECT answer is based on the ACTUAL
>>>>>>>> BEHAVIOR of the ACUTAL INPUT?
>>>>>>>>
>>>>>>>> H's inability to determine that is WHY it gets the wrong answer,
>>>>>>>> not an excuse for it to do so.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> When you claim that I am incorrect it is merely an empty
>>>>>>>>> assertion utterly bereft of supporting reasoning.
>>>>>>>>
>>>>>>>> No, you LITERALLY are making an empty assertion, as you are
>>>>>>>> asserting something that never occurs.
>>>>>>>>
>>>>>>>> There is NO H that does a complete and correct simulation and
>>>>>>>> returns an answer. We can even argue that it doesn't do a correct
>>>>>>>> simulation since the last step of the simulation has an error as
>>>>>>>> it presumes the wrong behavior of the call to H that it encounter
>>>>>>>> (you can debate if this is an incorrect simulation or just unsound
>>>>>>>> logic).
>>>>>>>>
>>>>>>>>>
>>>>>>>>> A simulating halt decider continues to simulate its input until
>>>>>>>>> it correctly matches a correct infinite behavior pattern.
>>>>>>>>
>>>>>>>> Then why does you H abort too soon, as shown by the fact that the
>>>>>>>> complete simulation Simualte(P,P) does halt when H(P,P) returns 0?
>>>>>>>>
>>>>>>>> Just says that your H doesn't even meet your own definition.
>>>>>>>>
>>>>>>>>>
>>>>>>>>> void Px(ptr x)
>>>>>>>>> {
>>>>>>>>> int Halt_Status = Hx(x, x);
>>>>>>>>> if (Halt_Status)
>>>>>>>>> HERE: goto HERE;
>>>>>>>>> return;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>> Output("Input_Halts = ", Hx(Px, Px));
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> In order for me to actually be wrong you must be able to show
>>>>>>>>> that some simulating halt decider Hx could be defined such that
>>>>>>>>> its correct simulation of its input Px reaches the final state of
>>>>>>>>> Px in a finite number of steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope. H(P,P) is wrong
>>>>>>>
>>>>>>> ..then a mistake could be shown, if no mistake can be shown then it
>>>>>>> is not wrong.
>>>>>>
>>>>>> And it has been.
>>>>>>
>>>>>> Even YOU hav published the correct and complete simuliaton of the
>>>>>> input to H(P,P) being the trace of P(P) and Simulate(P,P)
>>>>>>
>>>>>>>
>>>>>>> I contend that that no simulating halt decider Hx can be defined
>>>>>>> such that its correctly simulated input Px could reach the final
>>>>>>> state of this simulated Px in any finite number of steps.
>>>>>>
>>>>>> So, that isn't the question.
>>>>>
>>>>> *I STIPULATE FOR THIS THREAD THAT IS THE QUESTION*
>>>>>
>>>>> Any rebuttal must show all of the steps of exactly how the input to
>>>>> Hx(Px,Px) correctly simulated by Hx reaches the final state of Px in
>>>>> a finite number of steps.
>>>>>
>>>>> ALTERNATIVELY YOU COULD SIMPLY ADMIT THE TRUTH
>>>>>
>>>>>
>>>>
>>>> You don't get to stipulate the test,
>>>
>>> In other words you know that my statement is correct and you are too
>>> dishonest to admit it.
>>>
>> Nope, shows you don't understand about requirements.
> Ultimately, you are a shit for brains fucking idiot because you have admitted unsatisfiable requirements.
>
> It is precisely because the requirements are unsatisfiable they amount to nothing other than The bottom/uninhabited type. Falsity.
>
> https://en.wikipedia.org/wiki/Bottom_type