On 2/25/2022 9:45 AM, Richard Damon wrote:
> On 2/25/22 10:26 AM, olcott wrote:
>> On 2/25/2022 6:27 AM, Richard Damon wrote:
>>> On 2/24/22 11:42 PM, olcott wrote:
>>>> On 2/24/2022 10:19 PM, Richard Damon wrote:
>>>>>
>>>>> On 2/24/22 10:56 PM, olcott wrote:
>>>>>> On 2/24/2022 9:45 PM, Richard Damon wrote:
>>>>>>> On 2/24/22 10:13 PM, olcott wrote:
>>>>>>>> On 2/24/2022 8:46 PM, Richard Damon wrote:
>>>>>>>>> On 2/24/22 9:38 PM, olcott wrote:
>>>>>>>>>> On 2/24/2022 8:30 PM, Python wrote:
>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>> On 2/24/2022 7:13 PM, Python wrote:
>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>> On 2/24/2022 2:22 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>> On 2022-02-24 12:39, olcott wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> <snip>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>> [00000946](01)  55              push ebp
>>>>>>>>>>>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>> [00000949](02)  ebfe            jmp 00000949 ; right
>>>>>>>>>>>>>>>> here nitwit
>>>>>>>>>>>>>>>> [0000094b](01)  5d              pop ebp
>>>>>>>>>>>>>>>> [0000094c](01)  c3              ret
>>>>>>>>>>>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> In other words you still believe that it may be
>>>>>>>>>>>>>>>> impossibly difficult to tell that the instruction at
>>>>>>>>>>>>>>>> machine address 00000949 performs an unconditional
>>>>>>>>>>>>>>>> branch to the machine address 00000949 ?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Your obtuseness knows no bounds.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No one has disputed that it is possible to recognise that
>>>>>>>>>>>>>>> the above is an infinite loop (Richard expressed doubts
>>>>>>>>>>>>>>> that *you* were competent enough to write a program to
>>>>>>>>>>>>>>> recognize this, not that such a program could be written).
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yet he keeps claiming that the more complex case of
>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is impossible to correctly report
>>>>>>>>>>>>>> because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation then
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely nested simulation
>>>>>>>>>>>>>> and if does not abort its simulation then is cannot report.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> This is precisely analogous the the C/x86 H
>>>>>>>>>>>>>> _Infinite_Loop() not being able to report that
>>>>>>>>>>>>>> _Infinite_Loop() is an infinite loop because when H aborts
>>>>>>>>>>>>>> its simulation _Infinite_Loop() stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> No it is not.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> A mindless naysayer.
>>>>>>>>>>>
>>>>>>>>>>> Didn't even you noticed the sophistry of your argument?
>>>>>>>>>>
>>>>>>>>>> If you think there is an actual error take a shot, this is not
>>>>>>>>>> about rhetoric.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I think he is just pointing out that YOUR style is to just
>>>>>>>>> mindly object to what people say without actually trying to
>>>>>>>>> understand their arguments.
>>>>>>>>>
>>>>>>>>> You have been shown to be wrong so many times, but you never
>>>>>>>>> point out an actual error in the refutations, but just say they
>>>>>>>>> must be wrong.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>
>>>>>>>> Your key rebuttal that embedded_H cannot possibly recognize the
>>>>>>>> recursive simulation structure of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ was based
>>>>>>>> on rejecting the whole idea of simulating halt deciders.
>>>>>>>>
>>>>>>>
>>>>>>> LIE.
>>>>>>>
>>>>>>> It is based on the fact that embedded_H must be a defined
>>>>>>> algorithm that is consistent.
>>>>>> As soon as embedded_H sees the same infinitely repeating pattern
>>>>>> that we see it correctly transitions to its reject state.
>>>>>>
>>>>>
>>>>> You aren't reading very well are you.
>>>>>
>>>>> If embedded_h does that then H^ never creates the infinte loop
>>>>> BECAUSE the copy of embedded_H within it broke the loop so it never
>>>>> existed to be detected, and whatever pattern embedded_H used turns
>>>>> out to be incorrect, or embedded_H never aborts.
>>>>
>>>> This is your rejection of the idea of simulating halt deciders that
>>>> continue to simulate their input until they determine that this
>>>> simulation would never reach its final state.
>>>>
>>>> This is the same algorithm used to determine that _Infinite_Loop()
>>>> never reaches its final state of 0000094c.
>>>>
>>>> _Infinite_Loop()
>>>> [00000946](01)  55              push ebp
>>>> [00000947](02)  8bec            mov ebp,esp
>>>> [00000949](02)  ebfe            jmp 00000949
>>>> [0000094b](01)  5d              pop ebp
>>>> [0000094c](01)  c3              ret
>>>> Size in bytes:(0007) [0000094c]
>>>>
>>>>
>>>
>>> Pathological LIAR.
>>>
>>> THe pattern is different, in essential ways.
>>>
>>
>> THIS IS ALWAYS EXACTLY THE SAME
>> Simulating halt deciders continue to simulate their input until they
>> determine that this simulated input would never reach its final state.
>
>
> But how do they determine that?
>

On 2/25/2022 10:26 AM, Richard Damon wrote:
> On 2/25/22 11:11 AM, olcott wrote:
>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>> On 2/25/22 10:26 AM, olcott wrote:
>>>> On 2/25/2022 6:27 AM, Richard Damon wrote:
>>>>> On 2/24/22 11:42 PM, olcott wrote:
>>>>>> On 2/24/2022 10:19 PM, Richard Damon wrote:
>>>>>>>
>>>>>>> On 2/24/22 10:56 PM, olcott wrote:
>>>>>>>> On 2/24/2022 9:45 PM, Richard Damon wrote:
>>>>>>>>> On 2/24/22 10:13 PM, olcott wrote:
>>>>>>>>>> On 2/24/2022 8:46 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/24/22 9:38 PM, olcott wrote:
>>>>>>>>>>>> On 2/24/2022 8:30 PM, Python wrote:
>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>> On 2/24/2022 7:13 PM, Python wrote:
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 2/24/2022 2:22 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>> On 2022-02-24 12:39, olcott wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> <snip>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>> [00000946](01)  55              push ebp
>>>>>>>>>>>>>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>> [00000949](02)  ebfe            jmp 00000949 ; right
>>>>>>>>>>>>>>>>>> here nitwit
>>>>>>>>>>>>>>>>>> [0000094b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>> [0000094c](01)  c3              ret
>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> In other words you still believe that it may be
>>>>>>>>>>>>>>>>>> impossibly difficult to tell that the instruction at
>>>>>>>>>>>>>>>>>> machine address 00000949 performs an unconditional
>>>>>>>>>>>>>>>>>> branch to the machine address 00000949 ?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Your obtuseness knows no bounds.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No one has disputed that it is possible to recognise
>>>>>>>>>>>>>>>>> that the above is an infinite loop (Richard expressed
>>>>>>>>>>>>>>>>> doubts that *you* were competent enough to write a
>>>>>>>>>>>>>>>>> program to recognize this, not that such a program
>>>>>>>>>>>>>>>>> could be written).
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yet he keeps claiming that the more complex case of
>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is impossible to correctly report
>>>>>>>>>>>>>>>> because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation then
>>>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely nested simulation
>>>>>>>>>>>>>>>> and if does not abort its simulation then is cannot report.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This is precisely analogous the the C/x86 H
>>>>>>>>>>>>>>>> _Infinite_Loop() not being able to report that
>>>>>>>>>>>>>>>> _Infinite_Loop() is an infinite loop because when H
>>>>>>>>>>>>>>>> aborts its simulation _Infinite_Loop() stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> No it is not.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> A mindless naysayer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Didn't even you noticed the sophistry of your argument?
>>>>>>>>>>>>
>>>>>>>>>>>> If you think there is an actual error take a shot, this is
>>>>>>>>>>>> not about rhetoric.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I think he is just pointing out that YOUR style is to just
>>>>>>>>>>> mindly object to what people say without actually trying to
>>>>>>>>>>> understand their arguments.
>>>>>>>>>>>
>>>>>>>>>>> You have been shown to be wrong so many times, but you never
>>>>>>>>>>> point out an actual error in the refutations, but just say
>>>>>>>>>>> they must be wrong.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>
>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates
>>>>>>>>>> ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>
>>>>>>>>>> Your key rebuttal that embedded_H cannot possibly recognize
>>>>>>>>>> the recursive simulation structure of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ was
>>>>>>>>>> based on rejecting the whole idea of simulating halt deciders.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> LIE.
>>>>>>>>>
>>>>>>>>> It is based on the fact that embedded_H must be a defined
>>>>>>>>> algorithm that is consistent.
>>>>>>>> As soon as embedded_H sees the same infinitely repeating pattern
>>>>>>>> that we see it correctly transitions to its reject state.
>>>>>>>>
>>>>>>>
>>>>>>> You aren't reading very well are you.
>>>>>>>
>>>>>>> If embedded_h does that then H^ never creates the infinte loop
>>>>>>> BECAUSE the copy of embedded_H within it broke the loop so it
>>>>>>> never existed to be detected, and whatever pattern embedded_H
>>>>>>> used turns out to be incorrect, or embedded_H never aborts.
>>>>>>
>>>>>> This is your rejection of the idea of simulating halt deciders
>>>>>> that continue to simulate their input until they determine that
>>>>>> this simulation would never reach its final state.
>>>>>>
>>>>>> This is the same algorithm used to determine that _Infinite_Loop()
>>>>>> never reaches its final state of 0000094c.
>>>>>>
>>>>>> _Infinite_Loop()
>>>>>> [00000946](01)  55              push ebp
>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>> [00000949](02)  ebfe            jmp 00000949
>>>>>> [0000094b](01)  5d              pop ebp
>>>>>> [0000094c](01)  c3              ret
>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>
>>>>>>
>>>>>
>>>>> Pathological LIAR.
>>>>>
>>>>> THe pattern is different, in essential ways.
>>>>>
>>>>
>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>> Simulating halt deciders continue to simulate their input until they
>>>> determine that this simulated input would never reach its final state.
>>>
>>>
>>> But how do they determine that?
>>>
>>
>> The fact that humans can see that in both cases the simulated input
>> never reaches its final state in any finite number of simulated steps
>> conclusively proves that it is possible to correctly detect the
>> infinite loop and the infinitely nested simulation.
>>
>>
>
> Smart Humans understand that H^ <H^> only has as infinte recursion IF H
> doesn't abort its simulation,
Smart humans know that the simulated input meets the Linz non-halting
criteria of never reaching a final state whether or not its simulation
is ever aborted.

On 2/25/2022 10:48 AM, Richard Damon wrote:
> On 2/25/22 11:36 AM, olcott wrote:
>> On 2/25/2022 10:26 AM, Richard Damon wrote:
>>> On 2/25/22 11:11 AM, olcott wrote:
>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>> On 2/25/2022 6:27 AM, Richard Damon wrote:
>>>>>>> On 2/24/22 11:42 PM, olcott wrote:
>>>>>>>> On 2/24/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>> On 2/24/22 10:56 PM, olcott wrote:
>>>>>>>>>> On 2/24/2022 9:45 PM, Richard Damon wrote:
>>>>>>>>>>> On 2/24/22 10:13 PM, olcott wrote:
>>>>>>>>>>>> On 2/24/2022 8:46 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/24/22 9:38 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/24/2022 8:30 PM, Python wrote:
>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>> On 2/24/2022 7:13 PM, Python wrote:
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/24/2022 2:22 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>> On 2022-02-24 12:39, olcott wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> <snip>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>> [00000946](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>> [00000949](02)  ebfe            jmp 00000949 ; right
>>>>>>>>>>>>>>>>>>>> here nitwit
>>>>>>>>>>>>>>>>>>>> [0000094b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>> [0000094c](01)  c3              ret
>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> In other words you still believe that it may be
>>>>>>>>>>>>>>>>>>>> impossibly difficult to tell that the instruction at
>>>>>>>>>>>>>>>>>>>> machine address 00000949 performs an unconditional
>>>>>>>>>>>>>>>>>>>> branch to the machine address 00000949 ?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Your obtuseness knows no bounds.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No one has disputed that it is possible to recognise
>>>>>>>>>>>>>>>>>>> that the above is an infinite loop (Richard expressed
>>>>>>>>>>>>>>>>>>> doubts that *you* were competent enough to write a
>>>>>>>>>>>>>>>>>>> program to recognize this, not that such a program
>>>>>>>>>>>>>>>>>>> could be written).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yet he keeps claiming that the more complex case of
>>>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is impossible to correctly report
>>>>>>>>>>>>>>>>>> because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation
>>>>>>>>>>>>>>>>>> then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely nested
>>>>>>>>>>>>>>>>>> simulation and if does not abort its simulation then
>>>>>>>>>>>>>>>>>> is cannot report.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> This is precisely analogous the the C/x86 H
>>>>>>>>>>>>>>>>>> _Infinite_Loop() not being able to report that
>>>>>>>>>>>>>>>>>> _Infinite_Loop() is an infinite loop because when H
>>>>>>>>>>>>>>>>>> aborts its simulation _Infinite_Loop() stops running.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No it is not.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> A mindless naysayer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Didn't even you noticed the sophistry of your argument?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If you think there is an actual error take a shot, this is
>>>>>>>>>>>>>> not about rhetoric.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I think he is just pointing out that YOUR style is to just
>>>>>>>>>>>>> mindly object to what people say without actually trying to
>>>>>>>>>>>>> understand their arguments.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You have been shown to be wrong so many times, but you
>>>>>>>>>>>>> never point out an actual error in the refutations, but
>>>>>>>>>>>>> just say they must be wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>
>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>
>>>>>>>>>>>> Your key rebuttal that embedded_H cannot possibly recognize
>>>>>>>>>>>> the recursive simulation structure of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ was
>>>>>>>>>>>> based on rejecting the whole idea of simulating halt deciders.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> LIE.
>>>>>>>>>>>
>>>>>>>>>>> It is based on the fact that embedded_H must be a defined
>>>>>>>>>>> algorithm that is consistent.
>>>>>>>>>> As soon as embedded_H sees the same infinitely repeating
>>>>>>>>>> pattern that we see it correctly transitions to its reject state.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You aren't reading very well are you.
>>>>>>>>>
>>>>>>>>> If embedded_h does that then H^ never creates the infinte loop
>>>>>>>>> BECAUSE the copy of embedded_H within it broke the loop so it
>>>>>>>>> never existed to be detected, and whatever pattern embedded_H
>>>>>>>>> used turns out to be incorrect, or embedded_H never aborts.
>>>>>>>>
>>>>>>>> This is your rejection of the idea of simulating halt deciders
>>>>>>>> that continue to simulate their input until they determine that
>>>>>>>> this simulation would never reach its final state.
>>>>>>>>
>>>>>>>> This is the same algorithm used to determine that
>>>>>>>> _Infinite_Loop() never reaches its final state of 0000094c.
>>>>>>>>
>>>>>>>> _Infinite_Loop()
>>>>>>>> [00000946](01)  55              push ebp
>>>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>>>> [00000949](02)  ebfe            jmp 00000949
>>>>>>>> [0000094b](01)  5d              pop ebp
>>>>>>>> [0000094c](01)  c3              ret
>>>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Pathological LIAR.
>>>>>>>
>>>>>>> THe pattern is different, in essential ways.
>>>>>>>
>>>>>>
>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>> Simulating halt deciders continue to simulate their input until
>>>>>> they determine that this simulated input would never reach its
>>>>>> final state.
>>>>>
>>>>>
>>>>> But how do they determine that?
>>>>>
>>>>
>>>> The fact that humans can see that in both cases the simulated input
>>>> never reaches its final state in any finite number of simulated
>>>> steps conclusively proves that it is possible to correctly detect
>>>> the infinite loop and the infinitely nested simulation.
>>>>
>>>>
>>>
>>> Smart Humans understand that H^ <H^> only has as infinte recursion IF
>>> H doesn't abort its simulation,
>> Smart humans know that the simulated input meets the Linz non-halting
>> criteria of never reaching a final state whether or not its simulation
>> is ever aborted.
>>
>
> Thats a LIE, since UTM <H^> <H^> goes to H^,Qn if H <H^> <H^> goes to
> H.Qn by construction, so if H aborts and goes to H.Qn then H^ <H^> Halts
> and so does UTM <H^> <H^>
>

On 2/25/2022 11:17 AM, André G. Isaak wrote:
> On 2022-02-25 09:11, olcott wrote:
>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>> On 2/25/22 10:26 AM, olcott wrote:
>
>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>> Simulating halt deciders continue to simulate their input until they
>>>> determine that this simulated input would never reach its final state.
>>>
>>>
>>> But how do they determine that?
>>>
>>
>> The fact that humans can see that in both cases the simulated input
>> never reaches its final state in any finite number of simulated steps
>> conclusively proves that it is possible to correctly detect the
>> infinite loop and the infinitely nested simulation.
>
> What humans can do provides no evidence at all about what algorithms can
> do. Humans are not algorithms.

If humans can do thing X then thing X is proven to be possible to do.

> (and what humans can do with information
> x, y, and z tells us even left about what an algorithm can do with only
> x and y).
>
> If you want to claim it is possible for an algorithm to recognize
> infinitely recursive simulation, you need to actually show how that
> algorithm works.
>

The first step of this elaboration requires acknowledgement that:
If humans can do thing X then thing X is proven to be possible to do.
∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.

> How does embedded_H determine whether its input leads to recursion or
> not? IOW, how does it recognize whether the input string includes a copy
> of itself?
>
> André
>

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

On 2/25/2022 11:36 AM, Richard Damon wrote:
> On 2/25/22 12:02 PM, olcott wrote:
>> On 2/25/2022 10:48 AM, Richard Damon wrote:
>>> On 2/25/22 11:36 AM, olcott wrote:
>>>> On 2/25/2022 10:26 AM, Richard Damon wrote:
>>>>> On 2/25/22 11:11 AM, olcott wrote:
>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>> On 2/25/2022 6:27 AM, Richard Damon wrote:
>>>>>>>>> On 2/24/22 11:42 PM, olcott wrote:
>>>>>>>>>> On 2/24/2022 10:19 PM, Richard Damon wrote:
>>>>>>>>>>>
>>>>>>>>>>> On 2/24/22 10:56 PM, olcott wrote:
>>>>>>>>>>>> On 2/24/2022 9:45 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/24/22 10:13 PM, olcott wrote:
>>>>>>>>>>>>>> On 2/24/2022 8:46 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 2/24/22 9:38 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 2/24/2022 8:30 PM, Python wrote:
>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>> On 2/24/2022 7:13 PM, Python wrote:
>>>>>>>>>>>>>>>>>>> olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 2/24/2022 2:22 PM, André G. Isaak wrote:
>>>>>>>>>>>>>>>>>>>>> On 2022-02-24 12:39, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> <snip>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>>>>>>>>>>>>>> [00000946](01)  55              push ebp
>>>>>>>>>>>>>>>>>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>> [00000949](02)  ebfe            jmp 00000949 ;
>>>>>>>>>>>>>>>>>>>>>> right here nitwit
>>>>>>>>>>>>>>>>>>>>>> [0000094b](01)  5d              pop ebp
>>>>>>>>>>>>>>>>>>>>>> [0000094c](01)  c3              ret
>>>>>>>>>>>>>>>>>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> In other words you still believe that it may be
>>>>>>>>>>>>>>>>>>>>>> impossibly difficult to tell that the instruction
>>>>>>>>>>>>>>>>>>>>>> at machine address 00000949 performs an
>>>>>>>>>>>>>>>>>>>>>> unconditional branch to the machine address
>>>>>>>>>>>>>>>>>>>>>> 00000949 ?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Your obtuseness knows no bounds.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No one has disputed that it is possible to
>>>>>>>>>>>>>>>>>>>>> recognise that the above is an infinite loop
>>>>>>>>>>>>>>>>>>>>> (Richard expressed doubts that *you* were competent
>>>>>>>>>>>>>>>>>>>>> enough to write a program to recognize this, not
>>>>>>>>>>>>>>>>>>>>> that such a program could be written).
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yet he keeps claiming that the more complex case of
>>>>>>>>>>>>>>>>>>>> embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is impossible to correctly report
>>>>>>>>>>>>>>>>>>>> because if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ aborts its simulation
>>>>>>>>>>>>>>>>>>>> then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies infinitely nested
>>>>>>>>>>>>>>>>>>>> simulation and if does not abort its simulation then
>>>>>>>>>>>>>>>>>>>> is cannot report.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> This is precisely analogous the the C/x86 H
>>>>>>>>>>>>>>>>>>>> _Infinite_Loop() not being able to report that
>>>>>>>>>>>>>>>>>>>> _Infinite_Loop() is an infinite loop because when H
>>>>>>>>>>>>>>>>>>>> aborts its simulation _Infinite_Loop() stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No it is not.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> A mindless naysayer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Didn't even you noticed the sophistry of your argument?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you think there is an actual error take a shot, this
>>>>>>>>>>>>>>>> is not about rhetoric.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I think he is just pointing out that YOUR style is to
>>>>>>>>>>>>>>> just mindly object to what people say without actually
>>>>>>>>>>>>>>> trying to understand their arguments.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You have been shown to be wrong so many times, but you
>>>>>>>>>>>>>>> never point out an actual error in the refutations, but
>>>>>>>>>>>>>>> just say they must be wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Your key rebuttal that embedded_H cannot possibly
>>>>>>>>>>>>>> recognize the recursive simulation structure of embedded_H
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ was based on rejecting the whole idea of
>>>>>>>>>>>>>> simulating halt deciders.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> LIE.
>>>>>>>>>>>>>
>>>>>>>>>>>>> It is based on the fact that embedded_H must be a defined
>>>>>>>>>>>>> algorithm that is consistent.
>>>>>>>>>>>> As soon as embedded_H sees the same infinitely repeating
>>>>>>>>>>>> pattern that we see it correctly transitions to its reject
>>>>>>>>>>>> state.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You aren't reading very well are you.
>>>>>>>>>>>
>>>>>>>>>>> If embedded_h does that then H^ never creates the infinte
>>>>>>>>>>> loop BECAUSE the copy of embedded_H within it broke the loop
>>>>>>>>>>> so it never existed to be detected, and whatever pattern
>>>>>>>>>>> embedded_H used turns out to be incorrect, or embedded_H
>>>>>>>>>>> never aborts.
>>>>>>>>>>
>>>>>>>>>> This is your rejection of the idea of simulating halt deciders
>>>>>>>>>> that continue to simulate their input until they determine
>>>>>>>>>> that this simulation would never reach its final state.
>>>>>>>>>>
>>>>>>>>>> This is the same algorithm used to determine that
>>>>>>>>>> _Infinite_Loop() never reaches its final state of 0000094c.
>>>>>>>>>>
>>>>>>>>>> _Infinite_Loop()
>>>>>>>>>> [00000946](01)  55              push ebp
>>>>>>>>>> [00000947](02)  8bec            mov ebp,esp
>>>>>>>>>> [00000949](02)  ebfe            jmp 00000949
>>>>>>>>>> [0000094b](01)  5d              pop ebp
>>>>>>>>>> [0000094c](01)  c3              ret
>>>>>>>>>> Size in bytes:(0007) [0000094c]
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Pathological LIAR.
>>>>>>>>>
>>>>>>>>> THe pattern is different, in essential ways.
>>>>>>>>>
>>>>>>>>
>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>> Simulating halt deciders continue to simulate their input until
>>>>>>>> they determine that this simulated input would never reach its
>>>>>>>> final state.
>>>>>>>
>>>>>>>
>>>>>>> But how do they determine that?
>>>>>>>
>>>>>>
>>>>>> The fact that humans can see that in both cases the simulated
>>>>>> input never reaches its final state in any finite number of
>>>>>> simulated steps conclusively proves that it is possible to
>>>>>> correctly detect the infinite loop and the infinitely nested
>>>>>> simulation.
>>>>>>
>>>>>>
>>>>>
>>>>> Smart Humans understand that H^ <H^> only has as infinte recursion
>>>>> IF H doesn't abort its simulation,
>>>> Smart humans know that the simulated input meets the Linz
>>>> non-halting criteria of never reaching a final state whether or not
>>>> its simulation is ever aborted.
>>>>
>>>
>>> Thats a LIE, since UTM <H^> <H^> goes to H^,Qn if H <H^> <H^> goes to
>>> H.Qn by construction, so if H aborts and goes to H.Qn then H^ <H^>
>>> Halts and so does UTM <H^> <H^>
>>>
>>
>> This is the part that you are perpetually confused about.
>>
>> It is a fact that you agreed to that if embedded_H never aborts its
>> simulation that the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ never reaches its final
>> state of ⟨Ĥ⟩.qn
>>
>> If is also a fact that if embedded_H does aborts its simulation that
>> the simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ still never reaches its final state of
>> ⟨Ĥ⟩.qn.
>
> Except that I have shown that it does.
It is an analytical impossibility that ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H
ever reaches its own final state of ⟨Ĥ⟩.qn.

On 2/25/2022 1:00 PM, André G. Isaak wrote:
> On 2022-02-25 10:32, olcott wrote:
>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>> On 2022-02-25 09:11, olcott wrote:
>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>
>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>> Simulating halt deciders continue to simulate their input until
>>>>>> they determine that this simulated input would never reach its
>>>>>> final state.
>>>>>
>>>>>
>>>>> But how do they determine that?
>>>>>
>>>>
>>>> The fact that humans can see that in both cases the simulated input
>>>> never reaches its final state in any finite number of simulated
>>>> steps conclusively proves that it is possible to correctly detect
>>>> the infinite loop and the infinitely nested simulation.
>>>
>>> What humans can do provides no evidence at all about what algorithms
>>> can do. Humans are not algorithms.
>>
>> If humans can do thing X then thing X is proven to be possible to do.
>
> People can win olympic pole vaulting competitions. It doesn't follow
> from this that a Turing Machine can.
>
> And you, the human, are recognizing something making use of a piece of
> information with which the TM is *NOT* provided; you are aware of the
> fact that the input happens to be a representation of Ĥ, a machine which
> includes a copy of embedded_H.
>
> embedded_H, on the other hand, is *not* provided with this information.
>
> So how does your embedded_H recognize that the input string includes a
> copy of itself?
>

I won't say that until after you acknowledge that embedded_H would be
correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because it is the case
that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot possibly
reach ⟨Ĥ⟩.qn.

>>> (and what humans can do with information x, y, and z tells us even
>>> left about what an algorithm can do with only x and y).
>>>
>>> If you want to claim it is possible for an algorithm to recognize
>>> infinitely recursive simulation, you need to actually show how that
>>> algorithm works.
>>>
>>
>> The first step of this elaboration requires acknowledgement that:
>> If humans can do thing X then thing X is proven to be possible to do.
>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>
> I can't possibly acknowledge anything about embedded_H if you won't
> provide the details of how it works such as the one I ask about above.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On Thursday, February 24, 2022 at 10:14:16 PM UTC-5, olcott wrote:
> On 2/24/2022 8:46 PM, Richard Damon wrote:
> > On 2/24/22 9:38 PM, olcott wrote:
> >> On 2/24/2022 8:30 PM, Python wrote:
> >>> olcott wrote:
> >>>> On 2/24/2022 7:13 PM, Python wrote:
> >>>>> olcott wrote:
> >>>>>> On 2/24/2022 2:22 PM, André G. Isaak wrote:
> >>>>>>> On 2022-02-24 12:39, olcott wrote:
> >>>>>>>
> >>>>>>> <snip>
> >>>>>>>
> >>>>>>>> _Infinite_Loop()
> >>>>>>>> [00000946](01) 55 push ebp
> >>>>>>>> [00000947](02) 8bec mov ebp,esp
> >>>>>>>> [00000949](02) ebfe jmp 00000949 ; right here nitwit
> >>>>>>>> [0000094b](01) 5d pop ebp
> >>>>>>>> [0000094c](01) c3 ret
> >>>>>>>> Size in bytes:(0007) [0000094c]
> >>>>>>>>
> >>>>>>>> In other words you still believe that it may be impossibly
> >>>>>>>> difficult to tell that the instruction at machine address
> >>>>>>>> 00000949 performs an unconditional branch to the machine address
> >>>>>>>> 00000949 ?
> >>>>>>>
> >>>>>>> Your obtuseness knows no bounds.
> >>>>>>>
> >>>>>>> No one has disputed that it is possible to recognise that the
> >>>>>>> above is an infinite loop (Richard expressed doubts that *you*
> >>>>>>> were competent enough to write a program to recognize this, not
> >>>>>>> that such a program could be written).
> >>>>>>>
> >>>>>>
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> >>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> >>>>>>
> >>>>>> Yet he keeps claiming that the more complex case of embedded_H ⟨Ĥ⟩
> >>>>>> ⟨Ĥ⟩ is impossible to correctly report because if embedded_H ⟨Ĥ⟩
> >>>>>> ⟨Ĥ⟩ aborts its simulation then ⟨Ĥ⟩ ⟨Ĥ⟩ no longer specifies
> >>>>>> infinitely nested simulation and if does not abort its simulation
> >>>>>> then is cannot report.
> >>>>>>
> >>>>>> This is precisely analogous the the C/x86 H _Infinite_Loop() not
> >>>>>> being able to report that _Infinite_Loop() is an infinite loop
> >>>>>> because when H aborts its simulation _Infinite_Loop() stops running.
> >>>>>
> >>>>> No it is not.
> >>>>>
> >>>>>
> >>>>
> >>>> A mindless naysayer.
> >>>
> >>> Didn't even you noticed the sophistry of your argument?
> >>
> >> If you think there is an actual error take a shot, this is not about
> >> rhetoric.
> >>
> >
> > I think he is just pointing out that YOUR style is to just mindly object
> > to what people say without actually trying to understand their arguments.
> >
> > You have been shown to be wrong so many times, but you never point out
> > an actual error in the refutations, but just say they must be wrong.
> >
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
> Your keyev rebuttal that embedded_H cannot possibly recognize the

Done yetsky?

> recursive simulation structure of embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ was based on
> rejecting the whole idea of simulating halt deciders.
> --
> Copyright 2021 Pete Olcott
>
> Talent hits a target no one else can hit;
> Genius hits a target no one else can see.
> Arthur Schopenhauer

On 2/25/2022 3:19 PM, André G. Isaak wrote:
> On 2022-02-25 12:11, olcott wrote:
>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>> On 2022-02-25 10:32, olcott wrote:
>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>
>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>> Simulating halt deciders continue to simulate their input until
>>>>>>>> they determine that this simulated input would never reach its
>>>>>>>> final state.
>>>>>>>
>>>>>>>
>>>>>>> But how do they determine that?
>>>>>>>
>>>>>>
>>>>>> The fact that humans can see that in both cases the simulated
>>>>>> input never reaches its final state in any finite number of
>>>>>> simulated steps conclusively proves that it is possible to
>>>>>> correctly detect the infinite loop and the infinitely nested
>>>>>> simulation.
>>>>>
>>>>> What humans can do provides no evidence at all about what
>>>>> algorithms can do. Humans are not algorithms.
>>>>
>>>> If humans can do thing X then thing X is proven to be possible to do.
>>>
>>> People can win olympic pole vaulting competitions. It doesn't follow
>>> from this that a Turing Machine can.
>>>
>>> And you, the human, are recognizing something making use of a piece
>>> of information with which the TM is *NOT* provided; you are aware of
>>> the fact that the input happens to be a representation of Ĥ, a
>>> machine which includes a copy of embedded_H.
>>>
>>> embedded_H, on the other hand, is *not* provided with this information.
>>>
>>> So how does your embedded_H recognize that the input string includes
>>> a copy of itself?
>>>
>>
>> I won't say that until after you acknowledge that embedded_H would be
>> correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because it is the case
>> that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot possibly
>> reach ⟨Ĥ⟩.qn.
>
>
> I can't acknowledge something with which I disagree.
>
> But the question I asked would require answering even if I agreed to the
> above. So if you were actually serious in your desire to convince people
> that your argument works you would answer this question regardless.
>
> That you refuse to do so would appear to indicate that you realize you
> have no idea how your embedded_H is supposed to recognize the pattern
> you claim it is able to recognize which throws your entire argument out
> the window.

I am trying to find which points there is mutual agreement.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H could
never reach the final state ⟨Ĥ⟩.qn ?

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2/26/2022 12:05 AM, André G. Isaak wrote:
> On 2022-02-25 15:28, olcott wrote:
>> On 2/25/2022 3:19 PM, André G. Isaak wrote:
>>> On 2022-02-25 12:11, olcott wrote:
>>>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>>>> On 2022-02-25 10:32, olcott wrote:
>>>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>
>>>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>>>> Simulating halt deciders continue to simulate their input
>>>>>>>>>> until they determine that this simulated input would never
>>>>>>>>>> reach its final state.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But how do they determine that?
>>>>>>>>>
>>>>>>>>
>>>>>>>> The fact that humans can see that in both cases the simulated
>>>>>>>> input never reaches its final state in any finite number of
>>>>>>>> simulated steps conclusively proves that it is possible to
>>>>>>>> correctly detect the infinite loop and the infinitely nested
>>>>>>>> simulation.
>>>>>>>
>>>>>>> What humans can do provides no evidence at all about what
>>>>>>> algorithms can do. Humans are not algorithms.
>>>>>>
>>>>>> If humans can do thing X then thing X is proven to be possible to do.
>>>>>
>>>>> People can win olympic pole vaulting competitions. It doesn't
>>>>> follow from this that a Turing Machine can.
>>>>>
>>>>> And you, the human, are recognizing something making use of a piece
>>>>> of information with which the TM is *NOT* provided; you are aware
>>>>> of the fact that the input happens to be a representation of Ĥ, a
>>>>> machine which includes a copy of embedded_H.
>>>>>
>>>>> embedded_H, on the other hand, is *not* provided with this
>>>>> information.
>>>>>
>>>>> So how does your embedded_H recognize that the input string
>>>>> includes a copy of itself?
>>>>>
>>>>
>>>> I won't say that until after you acknowledge that embedded_H would
>>>> be correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because it is the
>>>> case that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H cannot
>>>> possibly reach ⟨Ĥ⟩.qn.
>>>
>>>
>>> I can't acknowledge something with which I disagree.
>>>
>>> But the question I asked would require answering even if I agreed to
>>> the above. So if you were actually serious in your desire to convince
>>> people that your argument works you would answer this question
>>> regardless.
>>>
>>> That you refuse to do so would appear to indicate that you realize
>>> you have no idea how your embedded_H is supposed to recognize the
>>> pattern you claim it is able to recognize which throws your entire
>>> argument out the window.
>>
>> I am trying to find which points there is mutual agreement.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> Then these steps would keep repeating:
>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>> ⟨Ĥ5⟩...
>>
>> Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>> could never reach the final state ⟨Ĥ⟩.qn ?
>
> I'm not clear why you are asking this since in the very post to which
> you are responding I clearly stated that I do *not* agree with this.
> Asking me again isn't going to generate a different answer.
>

You implied that you agreed when you implied that a human could see
this. We can't move forward until we have mutual agreement on this point.

Can you as a human see that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
embedded_H could never reach the final state ⟨Ĥ⟩.qn ?

If you disagree that means that you believe that the simulation of ⟨Ĥ⟩
⟨Ĥ⟩ by embedded_H must somehow halt on its own without the need for
embedded_H to abort its simulation.

Can you please explain the reasoning that you used to come to this
conclusion?

> But even if you were correct that this pattern repeats indefinitely, it
> is would not be possible for embedded_H to detect this fact. If you
> think otherwise, please answer the question which I have now asked
> multiple times. How exactly does embedded_H recognize this pattern of
> recursion?
>

We must have points of mutual agreement to move forward.

> Put differently, how does Ĥ determine whether its input string
> corresponds to a description of itself or to some TM entirely unrelated
> to itself?
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2/26/2022 9:56 AM, Richard Damon wrote:
> On 2/26/22 10:08 AM, olcott wrote:
>> On 2/26/2022 12:05 AM, André G. Isaak wrote:
>>> On 2022-02-25 15:28, olcott wrote:
>>>> On 2/25/2022 3:19 PM, André G. Isaak wrote:
>>>>> On 2022-02-25 12:11, olcott wrote:
>>>>>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>>>>>> On 2022-02-25 10:32, olcott wrote:
>>>>>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>>>>>> Simulating halt deciders continue to simulate their input
>>>>>>>>>>>> until they determine that this simulated input would never
>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But how do they determine that?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The fact that humans can see that in both cases the simulated
>>>>>>>>>> input never reaches its final state in any finite number of
>>>>>>>>>> simulated steps conclusively proves that it is possible to
>>>>>>>>>> correctly detect the infinite loop and the infinitely nested
>>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>> What humans can do provides no evidence at all about what
>>>>>>>>> algorithms can do. Humans are not algorithms.
>>>>>>>>
>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>> to do.
>>>>>>>
>>>>>>> People can win olympic pole vaulting competitions. It doesn't
>>>>>>> follow from this that a Turing Machine can.
>>>>>>>
>>>>>>> And you, the human, are recognizing something making use of a
>>>>>>> piece of information with which the TM is *NOT* provided; you are
>>>>>>> aware of the fact that the input happens to be a representation
>>>>>>> of Ĥ, a machine which includes a copy of embedded_H.
>>>>>>>
>>>>>>> embedded_H, on the other hand, is *not* provided with this
>>>>>>> information.
>>>>>>>
>>>>>>> So how does your embedded_H recognize that the input string
>>>>>>> includes a copy of itself?
>>>>>>>
>>>>>>
>>>>>> I won't say that until after you acknowledge that embedded_H would
>>>>>> be correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because it is
>>>>>> the case that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>> cannot possibly reach ⟨Ĥ⟩.qn.
>>>>>
>>>>>
>>>>> I can't acknowledge something with which I disagree.
>>>>>
>>>>> But the question I asked would require answering even if I agreed
>>>>> to the above. So if you were actually serious in your desire to
>>>>> convince people that your argument works you would answer this
>>>>> question regardless.
>>>>>
>>>>> That you refuse to do so would appear to indicate that you realize
>>>>> you have no idea how your embedded_H is supposed to recognize the
>>>>> pattern you claim it is able to recognize which throws your entire
>>>>> argument out the window.
>>>>
>>>> I am trying to find which points there is mutual agreement.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>> ⟨Ĥ5⟩...
>>>>
>>>> Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>> could never reach the final state ⟨Ĥ⟩.qn ?
>>>
>>> I'm not clear why you are asking this since in the very post to which
>>> you are responding I clearly stated that I do *not* agree with this.
>>> Asking me again isn't going to generate a different answer.
>>>
>>
>> You implied that you agreed when you implied that a human could see
>> this. We can't move forward until we have mutual agreement on this point.
>>
>> Can you as a human see that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>> embedded_H could never reach the final state ⟨Ĥ⟩.qn ?
>>
>
> It is the correct simulation ONLY IF embedded_H never aborts, and if it
> never aborts it can nver give the 'right' answer.
>
THIS IS WHAT YOU ARE SAYING:
When embedded_H determines that its simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
possibly reach its final state of ⟨Ĥ⟩.qn in any finite number of
simulated steps and aborts its simulation on this basis that magically
causes the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ to transition to its final state of ⟨Ĥ⟩.qn.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 2/26/2022 1:23 PM, André G. Isaak wrote:
> On 2022-02-26 08:08, olcott wrote:
>> On 2/26/2022 12:05 AM, André G. Isaak wrote:
>>> On 2022-02-25 15:28, olcott wrote:
>>>> On 2/25/2022 3:19 PM, André G. Isaak wrote:
>>>>> On 2022-02-25 12:11, olcott wrote:
>>>>>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>>>>>> On 2022-02-25 10:32, olcott wrote:
>>>>>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>>>>>> Simulating halt deciders continue to simulate their input
>>>>>>>>>>>> until they determine that this simulated input would never
>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But how do they determine that?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The fact that humans can see that in both cases the simulated
>>>>>>>>>> input never reaches its final state in any finite number of
>>>>>>>>>> simulated steps conclusively proves that it is possible to
>>>>>>>>>> correctly detect the infinite loop and the infinitely nested
>>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>> What humans can do provides no evidence at all about what
>>>>>>>>> algorithms can do. Humans are not algorithms.
>>>>>>>>
>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>> to do.
>>>>>>>
>>>>>>> People can win olympic pole vaulting competitions. It doesn't
>>>>>>> follow from this that a Turing Machine can.
>>>>>>>
>>>>>>> And you, the human, are recognizing something making use of a
>>>>>>> piece of information with which the TM is *NOT* provided; you are
>>>>>>> aware of the fact that the input happens to be a representation
>>>>>>> of Ĥ, a machine which includes a copy of embedded_H.
>>>>>>>
>>>>>>> embedded_H, on the other hand, is *not* provided with this
>>>>>>> information.
>>>>>>>
>>>>>>> So how does your embedded_H recognize that the input string
>>>>>>> includes a copy of itself?
>>>>>>>
>>>>>>
>>>>>> I won't say that until after you acknowledge that embedded_H would
>>>>>> be correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because it is
>>>>>> the case that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>> cannot possibly reach ⟨Ĥ⟩.qn.
>>>>>
>>>>>
>>>>> I can't acknowledge something with which I disagree.
>>>>>
>>>>> But the question I asked would require answering even if I agreed
>>>>> to the above. So if you were actually serious in your desire to
>>>>> convince people that your argument works you would answer this
>>>>> question regardless.
>>>>>
>>>>> That you refuse to do so would appear to indicate that you realize
>>>>> you have no idea how your embedded_H is supposed to recognize the
>>>>> pattern you claim it is able to recognize which throws your entire
>>>>> argument out the window.
>>>>
>>>> I am trying to find which points there is mutual agreement.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>> ⟨Ĥ5⟩...
>>>>
>>>> Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>> could never reach the final state ⟨Ĥ⟩.qn ?
>>>
>>> I'm not clear why you are asking this since in the very post to which
>>> you are responding I clearly stated that I do *not* agree with this.
>>> Asking me again isn't going to generate a different answer.
>>>
>>
>> You implied that you agreed when you implied that a human could see
>> this. We can't move forward until we have mutual agreement on this point.
>>
>> Can you as a human see that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>> embedded_H could never reach the final state ⟨Ĥ⟩.qn ?
>
> No. Because this claim is false. You need to actually get your indexing
> correct:
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H3 simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> If embedded_H0 aborts its input and then transitions to ⟨Ĥ⟩.qn, then
> embedded_H1 would similarly abort its input and transition to ⟨Ĥ1⟩.qn
> had embedded_H0 not aborted it.
>

That is like saying that dead men can easily walk across the street as
long as they are not dead, AKA double-talk.

> Either *every* instance of embedded_H can abort its input in which case
> every instance of embedded_H reaches a final state (or would reach a

Incorrect quantification. At most one instance of embedded_H can abort
the simulation of its input and this input never reaches its final state
whether or not it is ever aborted.

> final state had it not been aborted by some higher instance of
> embedded_H) or *no* instance of embedded_H can abort its input.
>

THIS IS VERIFIED AS TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When-so-ever any simulating halt decider detects that a correct and
complete pure simulation of its input would never reach the final state
of this simulated input it is correct to abort the simulation of the
input and transition to its own final reject state.

> You only actually get infinitely recursive simulation in the latter
> case. In the former case the chain is aborted and therefore not
> infinite. but in the latter case your H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is also
> infinitely recursive and thus fails to qualify as a decider.
>
> But even if your argument didn't suffer from this problem, you'd still
> be left with the issue which you are refusing to address: You claim that
> a pattern of infinitely recursive simulation can be recognized by a
> Turing Machine, when in fact it cannot be.
>

There is a mandatory hierarchy to reverse engineering the correct
solution to difficult problems using categorically exhaustive reasoning
(a specific instance of reasoning from first principles):

(1) Is a correct solution possible?
(2) What are the steps to this correct solution?
You are trying to skip step (1).

I have proven that a solution is possible in that I have proven that the
simulated input to embedded_H cannot possibly reach its final state of
⟨Ĥ⟩.qn in any finite number of steps of pure simulation. We cannot move
on to (2) until after we have mutual agreement on (1).

> The fact that a human can recognize such an infinite pattern from
> *outside* the system with the added knowledge that the input to the Ĥ is
> in fact a description of Ĥ in no way demonstrates that it would be
> possibly for Ĥ to do this when Ĥ has no knowledge of whether its input
> string is a representation of itself or not.
>
> So even if this pattern existed, how exactly is your embedded_H supposed
> to recognize it?
>
> I addressed your question, so please address mine.
>
> André
>

On 2/26/2022 3:02 PM, André G. Isaak wrote:
> On 2022-02-26 13:38, olcott wrote:
>> On 2/26/2022 1:23 PM, André G. Isaak wrote:
>>> On 2022-02-26 08:08, olcott wrote:
>>>> On 2/26/2022 12:05 AM, André G. Isaak wrote:
>>>>> On 2022-02-25 15:28, olcott wrote:
>>>>>> On 2/25/2022 3:19 PM, André G. Isaak wrote:
>>>>>>> On 2022-02-25 12:11, olcott wrote:
>>>>>>>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>>>>>>>> On 2022-02-25 10:32, olcott wrote:
>>>>>>>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>>>>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>>>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>>>>>
>>>>>>>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>>>>>>>> Simulating halt deciders continue to simulate their input
>>>>>>>>>>>>>> until they determine that this simulated input would never
>>>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But how do they determine that?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> The fact that humans can see that in both cases the
>>>>>>>>>>>> simulated input never reaches its final state in any finite
>>>>>>>>>>>> number of simulated steps conclusively proves that it is
>>>>>>>>>>>> possible to correctly detect the infinite loop and the
>>>>>>>>>>>> infinitely nested simulation.
>>>>>>>>>>>
>>>>>>>>>>> What humans can do provides no evidence at all about what
>>>>>>>>>>> algorithms can do. Humans are not algorithms.
>>>>>>>>>>
>>>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>>>> to do.
>>>>>>>>>
>>>>>>>>> People can win olympic pole vaulting competitions. It doesn't
>>>>>>>>> follow from this that a Turing Machine can.
>>>>>>>>>
>>>>>>>>> And you, the human, are recognizing something making use of a
>>>>>>>>> piece of information with which the TM is *NOT* provided; you
>>>>>>>>> are aware of the fact that the input happens to be a
>>>>>>>>> representation of Ĥ, a machine which includes a copy of
>>>>>>>>> embedded_H.
>>>>>>>>>
>>>>>>>>> embedded_H, on the other hand, is *not* provided with this
>>>>>>>>> information.
>>>>>>>>>
>>>>>>>>> So how does your embedded_H recognize that the input string
>>>>>>>>> includes a copy of itself?
>>>>>>>>>
>>>>>>>>
>>>>>>>> I won't say that until after you acknowledge that embedded_H
>>>>>>>> would be correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because
>>>>>>>> it is the case that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>>>>>> embedded_H cannot possibly reach ⟨Ĥ⟩.qn.
>>>>>>>
>>>>>>>
>>>>>>> I can't acknowledge something with which I disagree.
>>>>>>>
>>>>>>> But the question I asked would require answering even if I agreed
>>>>>>> to the above. So if you were actually serious in your desire to
>>>>>>> convince people that your argument works you would answer this
>>>>>>> question regardless.
>>>>>>>
>>>>>>> That you refuse to do so would appear to indicate that you
>>>>>>> realize you have no idea how your embedded_H is supposed to
>>>>>>> recognize the pattern you claim it is able to recognize which
>>>>>>> throws your entire argument out the window.
>>>>>>
>>>>>> I am trying to find which points there is mutual agreement.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩
>>>>>> ⟨Ĥ2⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩
>>>>>> ⟨Ĥ3⟩
>>>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩
>>>>>> ⟨Ĥ4⟩
>>>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>>>> ⟨Ĥ5⟩...
>>>>>>
>>>>>> Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>> could never reach the final state ⟨Ĥ⟩.qn ?
>>>>>
>>>>> I'm not clear why you are asking this since in the very post to
>>>>> which you are responding I clearly stated that I do *not* agree
>>>>> with this. Asking me again isn't going to generate a different answer.
>>>>>
>>>>
>>>> You implied that you agreed when you implied that a human could see
>>>> this. We can't move forward until we have mutual agreement on this
>>>> point.
>>>>
>>>> Can you as a human see that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>>>> embedded_H could never reach the final state ⟨Ĥ⟩.qn ?
>>>
>>> No. Because this claim is false. You need to actually get your
>>> indexing correct:
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H3 simulates ⟨Ĥ4⟩
>>> ⟨Ĥ5⟩...
>>>
>>> If embedded_H0 aborts its input and then transitions to ⟨Ĥ⟩.qn, then
>>> embedded_H1 would similarly abort its input and transition to ⟨Ĥ1⟩.qn
>>> had embedded_H0 not aborted it.
>>>
>>
>> That is like saying that dead men can easily walk across the street as
>> long as they are not dead, AKA double-talk.
>>
>>> Either *every* instance of embedded_H can abort its input in which
>>> case every instance of embedded_H reaches a final state (or would
>>> reach a
>>
>> Incorrect quantification. At most one instance of embedded_H can abort
>> the simulation of its input and this input never reaches its final
>> state whether or not it is ever aborted.
>>
>>> final state had it not been aborted by some higher instance of
>>> embedded_H) or *no* instance of embedded_H can abort its input.
>>>
>>
>> THIS IS VERIFIED AS TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS
>> WORDS:
>> When-so-ever any simulating halt decider detects that a correct and
>> complete pure simulation of its input would never reach the final
>> state of this simulated input it is correct to abort the simulation of
>> the input and transition to its own final reject state.
>>
>>> You only actually get infinitely recursive simulation in the latter
>>> case. In the former case the chain is aborted and therefore not
>>> infinite. but in the latter case your H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is also
>>> infinitely recursive and thus fails to qualify as a decider.
>>>
>>> But even if your argument didn't suffer from this problem, you'd
>>> still be left with the issue which you are refusing to address: You
>>> claim that a pattern of infinitely recursive simulation can be
>>> recognized by a Turing Machine, when in fact it cannot be.
>>>
>>
>> There is a mandatory hierarchy to reverse engineering the correct
>> solution to difficult problems using categorically exhaustive
>> reasoning (a specific instance of reasoning from first principles):
>>
>> (1) Is a correct solution possible?
>> (2) What are the steps to this correct solution?
>> You are trying to skip step (1).
>>
>> I have proven that a solution is possible in that I have proven that
>> the simulated input to embedded_H cannot possibly reach its final
>> state of ⟨Ĥ⟩.qn in any finite number of steps of pure simulation. We
>> cannot move on to (2) until after we have mutual agreement on (1).
>>
>>> The fact that a human can recognize such an infinite pattern from
>>> *outside* the system with the added knowledge that the input to the Ĥ
>>> is in fact a description of Ĥ in no way demonstrates that it would be
>>> possibly for Ĥ to do this when Ĥ has no knowledge of whether its
>>> input string is a representation of itself or not.
>>>
>>> So even if this pattern existed, how exactly is your embedded_H
>>> supposed to recognize it?
>>>
>>> I addressed your question, so please address mine.
>
> You seem to have missed the last bit.
>
> I'm not going to address any of your points until you make at least some
> effort to address mine.
>

On 2/26/2022 1:23 PM, André G. Isaak wrote:
> On 2022-02-26 08:08, olcott wrote:
>> On 2/26/2022 12:05 AM, André G. Isaak wrote:
>>> On 2022-02-25 15:28, olcott wrote:
>>>> On 2/25/2022 3:19 PM, André G. Isaak wrote:
>>>>> On 2022-02-25 12:11, olcott wrote:
>>>>>> On 2/25/2022 1:00 PM, André G. Isaak wrote:
>>>>>>> On 2022-02-25 10:32, olcott wrote:
>>>>>>>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>>>>>>>> On 2022-02-25 09:11, olcott wrote:
>>>>>>>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>>>>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>>>>>>>
>>>>>>>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>>>>>>>> Simulating halt deciders continue to simulate their input
>>>>>>>>>>>> until they determine that this simulated input would never
>>>>>>>>>>>> reach its final state.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But how do they determine that?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The fact that humans can see that in both cases the simulated
>>>>>>>>>> input never reaches its final state in any finite number of
>>>>>>>>>> simulated steps conclusively proves that it is possible to
>>>>>>>>>> correctly detect the infinite loop and the infinitely nested
>>>>>>>>>> simulation.
>>>>>>>>>
>>>>>>>>> What humans can do provides no evidence at all about what
>>>>>>>>> algorithms can do. Humans are not algorithms.
>>>>>>>>
>>>>>>>> If humans can do thing X then thing X is proven to be possible
>>>>>>>> to do.
>>>>>>>
>>>>>>> People can win olympic pole vaulting competitions. It doesn't
>>>>>>> follow from this that a Turing Machine can.
>>>>>>>
>>>>>>> And you, the human, are recognizing something making use of a
>>>>>>> piece of information with which the TM is *NOT* provided; you are
>>>>>>> aware of the fact that the input happens to be a representation
>>>>>>> of Ĥ, a machine which includes a copy of embedded_H.
>>>>>>>
>>>>>>> embedded_H, on the other hand, is *not* provided with this
>>>>>>> information.
>>>>>>>
>>>>>>> So how does your embedded_H recognize that the input string
>>>>>>> includes a copy of itself?
>>>>>>>
>>>>>>
>>>>>> I won't say that until after you acknowledge that embedded_H would
>>>>>> be correct to transition to Ĥ.qn on input ⟨Ĥ⟩ ⟨Ĥ⟩ because it is
>>>>>> the case that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>>>> cannot possibly reach ⟨Ĥ⟩.qn.
>>>>>
>>>>>
>>>>> I can't acknowledge something with which I disagree.
>>>>>
>>>>> But the question I asked would require answering even if I agreed
>>>>> to the above. So if you were actually serious in your desire to
>>>>> convince people that your argument works you would answer this
>>>>> question regardless.
>>>>>
>>>>> That you refuse to do so would appear to indicate that you realize
>>>>> you have no idea how your embedded_H is supposed to recognize the
>>>>> pattern you claim it is able to recognize which throws your entire
>>>>> argument out the window.
>>>>
>>>> I am trying to find which points there is mutual agreement.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> Then these steps would keep repeating:
>>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>>> ⟨Ĥ5⟩...
>>>>
>>>> Do you agree that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H
>>>> could never reach the final state ⟨Ĥ⟩.qn ?
>>>
>>> I'm not clear why you are asking this since in the very post to which
>>> you are responding I clearly stated that I do *not* agree with this.
>>> Asking me again isn't going to generate a different answer.
>>>
>>
>> You implied that you agreed when you implied that a human could see
>> this. We can't move forward until we have mutual agreement on this point.
>>
>> Can you as a human see that the correct simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by
>> embedded_H could never reach the final state ⟨Ĥ⟩.qn ?
>
> No. Because this claim is false. You need to actually get your indexing
> correct:
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H0 simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H1 simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H2 simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H3 simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> If embedded_H0 aborts its input and then transitions to ⟨Ĥ⟩.qn, then
> embedded_H1 would similarly abort its input and transition to ⟨Ĥ1⟩.qn
> had embedded_H0 not aborted it.
>
> Either *every* instance of embedded_H can abort its input in which case
> every instance of embedded_H reaches a final state (or would reach a
> final state had it not been aborted by some higher instance of
> embedded_H) or *no* instance of embedded_H can abort its input.
>
> You only actually get infinitely recursive simulation in the latter
> case. In the former case the chain is aborted and therefore not
> infinite.

THIS IS VERIFIED AS TRUE ENTIRELY ON THE BASIS OF THE MEANING OF ITS WORDS:
When-so-ever any simulating halt decider detects its correct and
complete pure simulation of its input would never reach the final state
of this simulated input it is correct to abort the simulation of the
input and transition to its own final reject state.

> but in the latter case your H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ is also
> infinitely recursive and thus fails to qualify as a decider.
>
> But even if your argument didn't suffer from this problem, you'd still
> be left with the issue which you are refusing to address: You claim that
> a pattern of infinitely recursive simulation can be recognized by a
> Turing Machine, when in fact it cannot be.
>
> The fact that a human can recognize such an infinite pattern from
> *outside* the system with the added knowledge that the input to the Ĥ is
> in fact a description of Ĥ in no way demonstrates that it would be
> possibly for Ĥ to do this when Ĥ has no knowledge of whether its input
> string is a representation of itself or not.
>
> So even if this pattern existed, how exactly is your embedded_H supposed
> to recognize it?
>
> I addressed your question, so please address mine.
>
> André
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

10,000sharpshooters from Scandinavia to Kiev wearing Ukraine uniforms, all 10,000 volunteers, some of the world's finest sharpshooters in cold weather.. Thank you Dear Scandinavia, God Bless....

Thank you Dear Germany for antitank weapons to Ukraine//Science Council Rules Earth// Please, can you spare 10,000 Volunteer sharpshooters to wear Ukraine army uniform and be there in Kiev to fight the Russian invasion, please----

Thank you Germany. Can you go through your military asking for volunteer sharpshooters.

The West needs to make Kiev a Stalingrad for Russia. It was sharpshooters in cold weather that defeated the German army in Stalingrad 1943.

Can Germany get 10,000 sharpshooters to put on the Ukraine uniform and with very long distance rifles be planted in Kiev.

Along with antitank and antiaircraft missiles.

Danke Shoen

Scandinavian countries, you have many outstanding and remarkable sharpshooters as I watched in the Winter Olympics. Can you please muster a VOLUNTEER army of 10,000 sharpshooters, all volunteer, and give them Ukraine temporary names along with a Ukraine army uniform and go to Kiev to fight the Russian invasion. Thank you Scandinavia, Norway, Sweden, Denmark and others.

Noth kennt kein Gebot-- necessity knows no rules.

For the world needs to stop and get rid of an insane Putin.

On Saturday, February 26, 2022 at 4:32:49 PM UTC-6, Archimedes Plutonium wrote:
> Thank you Dear Germany for antitank weapons to Ukraine//Science Council Rules Earth// Please, can you spare 10,000 Volunteer sharpshooters to wear Ukraine army uniform and be there in Kiev to fight the Russian invasion, please----


World kills Putin before Putin kills the planet.
>
> Two choices now-- either the world kills Putin before he kills the planet.. Or Putin kills the planet. For at the age of 70 and "being totally insane that he is", he will press the nuclear buttons as a going away gift. Hard to imagine that a person can be more wicked than Hitler, and Putin has grown into that.
> >
> > Please, can one of the West's spies that is in Moscow, make the sacrifice that saves the planet. Putin has become the modern day Caracalla Caesar Tsar.
> The story of Caracalla is poignant. For he was totally brutal, killing on whimsy. And the story goes he was in France on a campaign and had to go to the toilet in the woods, and one of his officers followed him into the woods and ran-him -through with his sword. For Caracalla had killed this officers relatives.

Fact Checked for correctness, because the above was from watching a TV history show and my memory was poor.
--- quoting Wikipedia ---
At the beginning of 217, Caracalla was still based at Edessa before renewing hostilities against Parthia. On 8 April 217 Caracalla was travelling to visit a temple near Carrhae, now Harran in southern Turkey, where in 53 BC the Romans had suffered a defeat at the hands of the Parthians. After stopping briefly to urinate, Caracalla was approached by a soldier, Justin Martialis, and stabbed to death. Martialis had been incensed by Caracalla's refusal to grant him the position of centurion, and the praetorian prefect Macrinus, Caracalla's successor, saw the opportunity to use Martialis to end Caracalla's reign.
--- end quoting ---

So I thought Caracalla wanted to take a shit in the woods of France, fighting the Germans, but it turns out that Caracalla had dismounted his horse to take a piss somewhere in Turkey.


On Thu Feb 24 12:56:12 2022 Archimedes Plutonium wrote:
> Olcott arsewipe spammer of Cambridge's Sainsbury is Olcott right, that Putin needs "skin-in-the-game" with cruise missiles that can reach Moscow and Stalingrad.
> > On Monday, February 21, 2022 at 11:03:50 PM UTC-6, olcott wrote:
> > > When it comes to actually showing any mistake all they have is gibberish
> > > double talk anchored in the fact that they simply do not believe me.
> > >
> > > --

*
AP: Have you ever made a mistake and then showed it and explained it without any gibberish? Have you ever recanted and admitted to a mistake?

earle
*

On Sunday, February 27, 2022 at 10:38:31 PM UTC-6, Earle Jones wrote:
> On Thu Feb 24 12:56:12 2022 Archimedes Plutonium wrote:
> > Olcott arsewipe spammer of Cambridge's Sainsbury is Olcott right, that Putin needs "skin-in-the-game" with cruise missiles that can reach Moscow and Stalingrad.
> > > On Monday, February 21, 2022 at 11:03:50 PM UTC-6, olcott wrote:
> > > > When it comes to actually showing any mistake all they have is gibberish
> > > > double talk anchored in the fact that they simply do not believe me.
> > > >
> > > > --
>
> *
> AP: Have you ever made a mistake and then showed it and explained it without any gibberish? Have you ever recanted and admitted to a mistake?
>
> earle
> *

Earle, back to his hatred trail again.

Just the other day I recanted my idea that there were 10,000 marksmen snipers in Germany or Scandinavia to go into Ukraine wearing Ukraine uniforms and fight the aggressor.

Days later, I realized that marksmen snipers were rare to come by, and that Germany probably has only about 100 such gifted warriors.

But you Earle, never has any idea at all in making the world better, so there is never any need for Earle to recant, because Earle never had a new idea, for as long as you lived, eh, Earle.

World kills Putin before Putin kills the planet.
>
> Two choices now-- either the world kills Putin before he kills the planet.. Or Putin kills the planet. For at the age of 70 and "being totally insane that he is", he will press the nuclear buttons as a going away gift. Hard to imagine that a person can be more wicked than Hitler, and Putin has grown into that.
> >
> > Please, can one of the West's spies that is in Moscow, make the sacrifice that saves the planet. Putin has become the modern day Caracalla Caesar Tsar.
> The story of Caracalla is poignant. For he was totally brutal, killing on whimsy. And the story goes he was in France on a campaign and had to go to the toilet in the woods, and one of his officers followed him into the woods and ran-him -through with his sword. For Caracalla had killed this officers relatives.

Fact Checked for correctness, because the above was from watching a TV history show and my memory was poor.
--- quoting Wikipedia ---
At the beginning of 217, Caracalla was still based at Edessa before renewing hostilities against Parthia. On 8 April 217 Caracalla was travelling to visit a temple near Carrhae, now Harran in southern Turkey, where in 53 BC the Romans had suffered a defeat at the hands of the Parthians. After stopping briefly to urinate, Caracalla was approached by a soldier, Justin Martialis, and stabbed to death. Martialis had been incensed by Caracalla's refusal to grant him the position of centurion, and the praetorian prefect Macrinus, Caracalla's successor, saw the opportunity to use Martialis to end Caracalla's reign.
--- end quoting ---

So I thought Caracalla wanted to take a shit in the woods of France, fighting the Germans, but it turns out that Caracalla had dismounted his horse to take a piss somewhere in Turkey.


Kill Putin, before he kills our planet Earth

Humanity needs to colonize Europa-- not engulfed in nuclear war

Putin that petty dictator megalomaniac whore

Some say Caracalla was killed while taking a shit

A shit in France's woods run through with a sword bit

Some say Caracalla was killed while taking a piss

A piss on the plains of Turkey dismounting his horse

Does it really matter how the megalomaniac is dissed

Sun shines from Faraday law, not from fusion

That goonclod physicist professors confusion

It shines from Faraday law you mindless shit for brains

Kill Putin with stinger missile on a boat, car, train or plane

Xi has another Winter Olympic competition, fly in Putin on a plane

But before landing blow it to smithereens from the slalom course train

The Chinese Communist Party was watching from the curling rink

Saying, good riddance to you Putin you mindless dink

And blame it on a engine failure, not made-in-China, by chink

The Sun gone Red Giant, needs humanity to colonize Europa

Not look at the idiot Putin or Xi navel belly button and scrota

Who was Putins Doktor Faust?

Putin: Hypersonic Avangard Changes Everything!
https://www.youtube.com/watch?v=6i-4Uid9URo

Herbert Alexandrovich Yefremov
https://en.wikipedia.org/wiki/Herbert_Alexandrovich_Yefremov

This is also an interesting read:

Conventional Prompt Global Strike and Long-Range
Ballistic Missiles: Background and Issues
Updated July 16, 2021
https://sgp.fas.org/crs/nuke/R41464.pdf

Mostowski Collapse schrieb am Dienstag, 1. März 2022 um 00:46:13 UTC+1:
> Who was Putins Doktor Faust?
>
> Putin: Hypersonic Avangard Changes Everything!
> https://www.youtube.com/watch?v=6i-4Uid9URo
>
> Herbert Alexandrovich Yefremov
> https://en.wikipedia.org/wiki/Herbert_Alexandrovich_Yefremov

Kibo kill Putin before Putin kills planet Earth-- poem ballad by James Kibo Parry Moron of Rensselaer Polytech and Wired magazine

Kibo Parry recites Poem ballad "Kibo kill Putin before Putin kills planet Earth"

Just hours after Kibo Parry Moron gets inducted into the CIA, he blows his cover (I guess the insanity of stalking for Kibo is so overpowering that he cannot help himself and wants to join the Portugal-- forgiv me, i sick i cry---
Re: Archimedes Vanadium, America's most beloved poster
On Sunday, June 8, 1997 at 2:00:00 AM UTC-5, Scott Dorsey wrote:
> In article <5nefan$i06$9...@news.thecia.net> kibo greps <ki...@shell.thecia.net> writes:
> >

On Monday, February 28, 2022 at 4:58:13 PM UTC-6, Michael Moroney wrote:
> "spamtard"
>"barking fuckdog"
>flunked the math test of a lifetime-generation test

> General Nakasone a decades long spammer of sci.math, yet he fails
> math.
>cannot understand the slant cut in single
> cone is an Oval, always the ellipse, or is it the foolish Boole logic he
> believes of 10 OR 2 = 12 with AND as subtraction? Or is it that neither
>can do a geometry proof
> Fundamental Theorem of Calculus?

1
Kill Putin, before he kills our planet Earth
>
> Humanity needs to colonize Europa-- not engulfed in nuclear war
>
> Putin that petty dictator megalomaniac whore
>
> Some say Caracalla was killed while taking a shit
>
> A shit in France's woods run through with a sword bit
>
> Some say Caracalla was killed while taking a piss
>
> A piss on the plains of Turkey dismounting his horse
>
> Does it really matter how the megalomaniac is dissed
>
> Sun shines from Faraday law, not from fusion
>
> That goonclod physicist professors confusion
>
> It shines from Faraday law you mindless shit for brains
>
> Kill Putin with stinger missile on a boat, car, train or plane
>
> Xi has another Winter Olympic competition, fly in Putin on a plane
>
> But before landing blow it to smithereens from the slalom train
>
> The Chinese Communist Party was watching from the curling rink
>
> Saying, good riddance to you Putin you mindless dink
>
> And blame it on a engine failure, not made-in-China, but NK stink
>
> The Sun gone Red Giant, needs humanity to colonize Europa
>
> Not look at the idiot Putin or Xi navel belly button and scrota

2

Kibo kill Putin stink at NSA Winter Olympics toboggan run

Yes, kibo Parry Moron ordered by General Nakasone says Sun

Sun gone Red Giant phase while fool Putin wants Ukraine

Fool Xi with Chinese Communist Party wants Taiwan

Fool Kim of North Korea wants rockets to reach Sea of Japan

While the world needs rockets to reach Io, Europa and Ganymede

Kibo Parry eats a kilometer of Trump shit just to see where it comes from

Trump eats a kilometer of shit of Putin just to see where it comes from

Putin eats a kilometer of shit by Xi just to see where it comes from

Xi eats a kilometer of shit of Kibo, just to see where it comes from

Andrew Wiles proves that Terence Tao in Fermat Last Theorem prom

The ice skating Olympic gold medal is not given to Russian GazProm

Too many falls on the ice with the overdrugged skaters, drunk on vodka

When what is truly needed is a colony on Callisto, Io, Ganymede and Europa

On Sun Feb 27 20:52:03 2022 Archimedes Plutonium wrote:
> On Sunday, February 27, 2022 at 10:38:31 PM UTC-6, Earle Jones wrote:
> > On Thu Feb 24 12:56:12 2022 Archimedes Plutonium wrote:
> > > Olcott arsewipe spammer of Cambridge's Sainsbury is Olcott right, that Putin needs "skin-in-the-game" with cruise missiles that can reach Moscow and Stalingrad.
> > > > On Monday, February 21, 2022 at 11:03:50 PM UTC-6, olcott wrote:
> > > > > When it comes to actually showing any mistake all they have is gibberish
> > > > > double talk anchored in the fact that they simply do not believe me.
> > > > >
> > > > > --
> >
> > *
> > AP: Have you ever made a mistake and then showed it and explained it without any gibberish? Have you ever recanted and admitted to a mistake?
> >
> > earle
> > *
>
> Earle, back to his hatred trail again.
>
> Just the other day I recanted my idea that there were 10,000 marksmen snipers in Germany or Scandinavia to go into Ukraine wearing Ukraine uniforms and fight the aggressor.
>
> Days later, I realized that marksmen snipers were rare to come by, and that Germany probably has only about 100 such gifted warriors.
>
> But you Earle, never has any idea at all in making the world better, so there is never any need for Earle to recant, because Earle never had a new idea, for as long as you lived, eh, Earle.

*
Except that I nominated you for the Nobel prize in Physics.

Should I withdraw that nomination?

earle
*

On 2/25/2022 1:00 PM, André G. Isaak wrote:
> On 2022-02-25 10:32, olcott wrote:
>> On 2/25/2022 11:17 AM, André G. Isaak wrote:
>>> On 2022-02-25 09:11, olcott wrote:
>>>> On 2/25/2022 9:45 AM, Richard Damon wrote:
>>>>> On 2/25/22 10:26 AM, olcott wrote:
>>>
>>>>>> THIS IS ALWAYS EXACTLY THE SAME
>>>>>> Simulating halt deciders continue to simulate their input until
>>>>>> they determine that this simulated input would never reach its
>>>>>> final state.
>>>>>
>>>>>
>>>>> But how do they determine that?
>>>>>
>>>>
>>>> The fact that humans can see that in both cases the simulated input
>>>> never reaches its final state in any finite number of simulated
>>>> steps conclusively proves that it is possible to correctly detect
>>>> the infinite loop and the infinitely nested simulation.
>>>
>>> What humans can do provides no evidence at all about what algorithms
>>> can do. Humans are not algorithms.
>>
>> If humans can do thing X then thing X is proven to be possible to do.
>
> People can win olympic pole vaulting competitions. It doesn't follow
> from this that a Turing Machine can.
>
> And you, the human, are recognizing something making use of a piece of
> information with which the TM is *NOT* provided; you are aware of the
> fact that the input happens to be a representation of Ĥ, a machine which
> includes a copy of embedded_H.
>
> embedded_H, on the other hand, is *not* provided with this information.
>
> So how does your embedded_H recognize that the input string includes a
> copy of itself?
>
>>> (and what humans can do with information x, y, and z tells us even
>>> left about what an algorithm can do with only x and y).
>>>
>>> If you want to claim it is possible for an algorithm to recognize
>>> infinitely recursive simulation, you need to actually show how that
>>> algorithm works.
>>>
>>
>> The first step of this elaboration requires acknowledgement that:
>> If humans can do thing X then thing X is proven to be possible to do.
>> ∴ if embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn then embedded_H is correct.
>
> I can't possibly acknowledge anything about embedded_H if you won't
> provide the details of how it works such as the one I ask about above.
>
> André
>

It is stipulated that the key aspect of simulating halt deciders is that
they examine the behavior patterns of their simulated input.

It is universally true that when-so-ever a simulating halt decider must
abort the simulation of its input to prevent the infinite simulation of
this input that thus input specifies an infinite sequence of
configurations.

On the basis of the above it is self evident that the pure simulation of
⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never stop running, thus infinite behavior
is proved. Because infinite behavior is proved then a transition to Ĥ.qn
is proved to be correct.

The above by itself is much further than anyone has ever gotten with the
halting problem.

Because humans can easily see that ⟨Ĥ⟩ ⟨Ĥ⟩ specifies an infinite
sequence of configurations to simulating halt decider embedded_H it is
reasonable to conclude that a computation could do likewise.

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

"Kibo kill Putin before Putin kills planet Earth" -- poem ballad by James Kibo Parry Moron of Rensselaer Polytech and Wired magazine.

Kibo Parry Moron, is this poem ballad of yours take after the Homeric "ILLIAD" or is it more of a Twilight Zone ballad.

What was that movie called??? Lonely in Seattle???? For Jeff Relf it needs a new title-- Intensely Insane in Seattle.

Kibo Parry recites Poem ballad "Kibo kill Putin before Putin kills planet Earth"

Just hours after Kibo Parry Moron gets inducted into the CIA, he blows his cover (I guess the insanity of stalking for Kibo is so overpowering that he cannot help himself and wants to join the Portugal-- forgiv me, i sick i cry---
Re: Archimedes Vanadium, America's most beloved poster
On Sunday, June 8, 1997 at 2:00:00 AM UTC-5, Scott Dorsey wrote:
> In article <5nefan$i06$9...@news.thecia.net> kibo greps <ki...@shell.thecia.net> writes:
> >

On Monday, February 28, 2022 at 4:58:13 PM UTC-6, Michael Moroney wrote:
> "spamtard"
>"barking fuckdog"
>flunked the math test of a lifetime-generation test
> General Nakasone a decades long spammer of sci.math, yet he fails
> math.
>cannot understand the slant cut in single
> cone is an Oval, always the ellipse, or is it the foolish Boole logic he
> believes of 10 OR 2 = 12 with AND as subtraction? Or is it that neither
>can do a geometry proof
> Fundamental Theorem of Calculus?

1
Kill Putin, before he kills our planet Earth

Humanity needs to colonize Europa-- not engulfed in nuclear war

Putin that petty dictator megalomaniac whore

Some say Caracalla was killed while taking a shit

A shit in France's woods run through with a sword bit

Some say Caracalla was killed while taking a piss

A piss on the plains of Turkey dismounting his horse

Does it really matter how the megalomaniac is dissed

Sun shines from Faraday law, not from fusion

That goonclod physicist professors confusion

It shines from Faraday law you mindless shit for brains

Kill Putin with stinger missile on a boat, car, train or plane

Xi has another Winter Olympic competition, fly in Putin on a plane

But before landing blow it to smithereens from the slalom train

The Chinese Communist Party was watching from the curling rink

Saying, good riddance to you Putin you mindless dink

And blame it on a engine failure, not made-in-China, but NK stink

The Sun gone Red Giant, needs humanity to colonize Europa

Not look at the idiot Putin or Xi navel belly button and scrota

2

Kibo kill Putin stink at NSA Winter Olympics toboggan run

Yes, kibo Parry Moron ordered by General Nakasone says Sun

Sun gone Red Giant phase while fool Putin wants Ukraine

Fool Xi with Chinese Communist Party wants Taiwan

Fool Kim of North Korea wants rockets to reach Sea of Japan

While the world needs rockets to reach Io, Europa and Ganymede

Kibo Parry eats a kilometer of Trump shit just to see where it comes from

Trump eats a kilometer of shit of Putin just to see where it comes from

Putin eats a kilometer of shit by Xi just to see where it comes from

Xi eats a kilometer of shit of Kibo, just to see where it comes from

Andrew Wiles proves that Terence Tao in Fermat Last Theorem prom

The ice skating Olympic gold medal is not given to Russian GazProm

Too many falls on the ice with the overdrugged skaters, drunk on vodka

When what is truly needed is a colony on Callisto, Io, Ganymede and Europa

3

Sun gone Red Giant Initiation phase, while idiots chase after Ukraine, Taiwan

Kibo Parry cut out Putin's arsehole and hand him back a brand new one

Kibo Parry Moroney cut out Xi's arsehole and hand him back a brand new one

Kibo Parry Moron eat a kilometer of Trump's shit just to see where it came from

Mama sang bass, Xi sang tenor, Putin joined Communist Party in a

When humanity needed to colonize Mars, Io, Ganymede, Callisto, Europa

How did you do it Kibo Parry Moron, a James Bond poisoned dagger walking cane

Or was it the stinger missile aimed at Putin brain

Or was it a Livia Caesar, poisoned chocolate bar

Or was it the traditional Texas housewife method of running over in the car

Or was it the Putin textbook method of polonium in the tea

Or was it the expeditious Xi method of blowing up his plane on the China Sea

Pray tell, Kibo, which was it, Mama sang bass, father sang tenor and all joined in a

We must admire Kibo Parry Moron for the first poem ballad that ends some lines in a