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:As soon as embedded_H sees the same infinitely repeating pattern that
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.
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.
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:As soon as embedded_H sees the same infinitely repeating pattern
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.
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/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:As soon as embedded_H sees the same infinitely repeating pattern
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.
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.
You are just too dumb to understand.
There is a FATAL flaw in your logic, and you are just going to DIE wrong.
You have FAILED and made yourself a laughing stock, and that is your
legacy.
If you were right, and have the program you have claimed, you would be
able to just write your paper and submit, but YOU know the program
doesn't work because of this fatal flaw that you refuse to admit, so you
are trying to find the weasel words to explain away the issue.
It won't work.
On 2/25/22 11:11 AM, olcott wrote:Smart humans know that the simulated input meets the Linz non-halting
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:As soon as embedded_H sees the same infinitely repeating pattern >>>>>>>> that we see it correctly transitions to its reject state.
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:If you think there is an actual error take a shot, this is >>>>>>>>>>>> not about rhetoric.
On 2/24/2022 7:13 PM, Python wrote:
olcott wrote:
On 2/24/2022 2:22 PM, André G. Isaak wrote:No it is not.
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. >>>>>>>>>>>>>>>
A mindless naysayer.
Didn't even you noticed the sophistry of your argument? >>>>>>>>>>>>
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.
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,
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:Smart humans know that the simulated input meets the Linz non-halting
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:As soon as embedded_H sees the same infinitely repeating
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:If you think there is an actual error take a shot, this is >>>>>>>>>>>>>> not about rhetoric.
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:No it is not.
<snip>
_Infinite_Loop()Your obtuseness knows no bounds.
[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 ? >>>>>>>>>>>>>>>>>>>
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. >>>>>>>>>>>>>>>>>
A mindless naysayer.
Didn't even you noticed the sophistry of your argument? >>>>>>>>>>>>>>
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.
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,
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^>
You make the error of thinking that the 'Simulation' that Linz is
talking about is the simulation done by H, which only counts if H is
actually a UTM, at which point it BY DEFINITION never aborts, so it is
not applicable for the case when H aborts.
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.
(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.
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é
On 2/25/22 12:02 PM, olcott wrote:It is an analytical impossibility that ⟨Ĥ⟩ ⟨Ĥ⟩ simulated by embedded_H
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:Smart humans know that the simulated input meets the Linz
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:As soon as embedded_H sees the same infinitely repeating >>>>>>>>>>>> pattern that we see it correctly transitions to its reject >>>>>>>>>>>> state.
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:If you think there is an actual error take a shot, this >>>>>>>>>>>>>>>> is not about rhetoric.
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:No it is not.
<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. >>>>>>>>>>>>>>>>>>>
A mindless naysayer.
Didn't even you noticed the sophistry of your argument? >>>>>>>>>>>>>>>>
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.
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,
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.
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é
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.
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:People can win olympic pole vaulting competitions. It doesn't
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. >>>>>
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.
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?
Put differently, how does Ĥ determine whether its input string
corresponds to a description of itself or to some TM entirely unrelated
to itself?
André
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.
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. 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é
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.
How does a TM determine that its input string is a representation of
itself?
André
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.
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é
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 297 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 127:37:04 |
| Calls: | 6,663 |
| Calls today: | 1 |
| Files: | 12,212 |
| Messages: | 5,335,087 |