On 2/24/2022 11:32 AM, Richard Damon wrote:
> On 2/24/22 12:01 PM, olcott wrote:
>> On 2/24/2022 10:55 AM, Richard Damon wrote:
>>> On 2/24/22 10:24 AM, olcott wrote:
>>>> On 2/24/2022 6:43 AM, Richard Damon wrote:
>>>>> On 2/23/22 11:31 PM, olcott wrote:
>>>>>> On 2/23/2022 9:36 PM, Richard Damon wrote:
>>>>>
>>>>>>> Then Analytic Truth is a sub-set of Truth. Just like the set of
>>>>>>> black cats doesn't contain all cats.
>>>>>>>
>>>>>>
>>>>>> Yes it is yet it encompasses all of mathematics and logic.
>>>>>
>>>>> As I think back, I now remember on key fact that you are missing.
>>>>> Analytic Truth requires Proof in a Finite (or sometimes Enumerable)
>>>>> number of proof steps.
>>>>>
>>>>
>>>> The body of analytic truth is simply a set of true sentences that
>>>> are connected together semantically.
>>>>
>>>>> Mathematics introduces the concept of UnEnumeratable sets and this
>>>>> is what breaks the concept of Truth must be Provable. Some things
>>>>> can be shown true only by a 'meta-analysis' that looks at an
>>>>> uncountable number of Proof Steps, which Analytic Truth can not
>>>>> handle, thus it can establish facts that are not Analytically
>>>>> provable.
>>>>>
>>>>
>>>> This merely requires algorithmic compression. We can know that there
>>>> is no maximum integer without having to actually count to infinity.
>>>
>>> But you can't compress ALL things. Your assupmtion that you can is a
>>> fallacy. For instance, you assume there must be a finite pattern that
>>> H can detect in its simulation of <H^> <H^> that correctly indicates
>>> that the pattern will repeat forever, when I have shown that no such
>>> pattern exists, as ANY pattern of N steps that H uses and then goes
>>> to H.Qn means that there IS a number K > N such that H^ applied to
>>> <H^> halts in K steps, thus H was wrong.
>>>
>>>>
>>>>> This also shows where you logic breaks down, you have show an
>>>>> inability to actually think about things that can become infinite.
>>>>> The problem with you H is that it actually needs infinite time to
>>>>> make a valid decision, but it needs to make it in a finite time,
>>>>> and thus it fails.
>>>>>
>>>>
>>>> That makes the utterly moronic assumption that the most intelligent
>>>> and knowledgeable person in the universe could not possibly spot the
>>>> infinite loop in the code shown below in less then infinite time:
>>>>
>>>> _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]
>>>>
>>>>
>>>
>>> Fallacy of proof by example. FAIL.
>>>
>>> That pattern is NOT in H^ applied to <H^>.
>>>
>>> I never claimed that H couldn't detect SOME infinite loops,
>>
>> You claimed that H could not correctly report that the above is an in
>> finite loop because if H stops simulating it then it is no longer an
>> infinite loop.
>
>
> LIAR.
>
> I said it could not do it for H^ applied to <H^>
>
> Shows how much you understand the truth.
So you acknowledge that in the C/x86, H does correctly decide that
_Infinite_Loop() never halts ?

--
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/24/2022 11:47 AM, Python wrote:
> Richard Damon wrote:
>> On 2/24/22 12:01 PM, olcott wrote:
>>> On 2/24/2022 10:55 AM, Richard Damon wrote:
>>>> On 2/24/22 10:24 AM, olcott wrote:
> ...
>>>>> That makes the utterly moronic assumption that the most intelligent
>>>>> and knowledgeable person in the universe could not possibly spot
>>>>> the infinite loop in the code shown below in less then infinite time:
>>>>>
>>>>> _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]
>>>>>
>>>>>
>>>>
>>>> Fallacy of proof by example. FAIL.
>>>>
>>>> That pattern is NOT in H^ applied to <H^>.
>>>>
>>>> I never claimed that H couldn't detect SOME infinite loops,
>>>
>>> You claimed that H could not correctly report that the above is an in
>>> finite loop because if H stops simulating it then it is no longer an
>>> infinite loop.
>>
>>
>> LIAR.
>>
>> I said it could not do it for H^ applied to <H^>
>>
>> Shows how much you understand the truth.
>>
>> The (allowed) 'pathological self-reference' in H^ <H^> is what defeats
>> H here.
>>
>> Your REPEATED misquoting of people and misuse of definitions just show
>> that YOU are a pathological LIAR and there is no Truth in you. YOU are
>> the one destined to be destroyed in the lake of fire to use the
>> passage you like to quote.
>
> This excerpt from this thread is absolutely devastating for Olcott, not
> only showing how fallacious is his claims, but how small integrity he
> has.
>

On 2/22/2022 10:13 PM, Richard Damon wrote:
>
> On 2/22/22 11:05 PM, olcott wrote:
>> _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]
>
> This doesn't present the pattern you just claim, so you just committed
> that fallacy of the Red Herring.

I claim that the pattern is infinite loop.

--
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/24/2022 11:32 AM, Richard Damon wrote:
> On 2/24/22 12:01 PM, olcott wrote:
>> On 2/24/2022 10:55 AM, Richard Damon wrote:
>>> On 2/24/22 10:24 AM, olcott wrote:
>>>> On 2/24/2022 6:43 AM, Richard Damon wrote:
>>>>> On 2/23/22 11:31 PM, olcott wrote:
>>>>>> On 2/23/2022 9:36 PM, Richard Damon wrote:
>>>>>
>>>>>>> Then Analytic Truth is a sub-set of Truth. Just like the set of
>>>>>>> black cats doesn't contain all cats.
>>>>>>>
>>>>>>
>>>>>> Yes it is yet it encompasses all of mathematics and logic.
>>>>>
>>>>> As I think back, I now remember on key fact that you are missing.
>>>>> Analytic Truth requires Proof in a Finite (or sometimes Enumerable)
>>>>> number of proof steps.
>>>>>
>>>>
>>>> The body of analytic truth is simply a set of true sentences that
>>>> are connected together semantically.
>>>>
>>>>> Mathematics introduces the concept of UnEnumeratable sets and this
>>>>> is what breaks the concept of Truth must be Provable. Some things
>>>>> can be shown true only by a 'meta-analysis' that looks at an
>>>>> uncountable number of Proof Steps, which Analytic Truth can not
>>>>> handle, thus it can establish facts that are not Analytically
>>>>> provable.
>>>>>
>>>>
>>>> This merely requires algorithmic compression. We can know that there
>>>> is no maximum integer without having to actually count to infinity.
>>>
>>> But you can't compress ALL things. Your assupmtion that you can is a
>>> fallacy. For instance, you assume there must be a finite pattern that
>>> H can detect in its simulation of <H^> <H^> that correctly indicates
>>> that the pattern will repeat forever, when I have shown that no such
>>> pattern exists, as ANY pattern of N steps that H uses and then goes
>>> to H.Qn means that there IS a number K > N such that H^ applied to
>>> <H^> halts in K steps, thus H was wrong.
>>>
>>>>
>>>>> This also shows where you logic breaks down, you have show an
>>>>> inability to actually think about things that can become infinite.
>>>>> The problem with you H is that it actually needs infinite time to
>>>>> make a valid decision, but it needs to make it in a finite time,
>>>>> and thus it fails.
>>>>>
>>>>
>>>> That makes the utterly moronic assumption that the most intelligent
>>>> and knowledgeable person in the universe could not possibly spot the
>>>> infinite loop in the code shown below in less then infinite time:
>>>>
>>>> _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]
>>>>
>>>>
>>>
>>> Fallacy of proof by example. FAIL.
>>>
>>> That pattern is NOT in H^ applied to <H^>.
>>>
>>> I never claimed that H couldn't detect SOME infinite loops,
>>
>> You claimed that H could not correctly report that the above is an in
>> finite loop because if H stops simulating it then it is no longer an
>> infinite loop.
>
>
> LIAR.
>

On 2/22/2022 10:13 PM, Richard Damon wrote:
>
> On 2/22/22 11:05 PM, olcott wrote:
>> _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]
>
> This doesn't present the pattern you just claim, so you just committed
> that fallacy of the Red Herring.

I claim that the pattern is infinite loop.

--
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/24/2022 12:51 PM, Richard Damon wrote:
> On 2/24/22 12:52 PM, olcott wrote:
>> On 2/24/2022 11:32 AM, Richard Damon wrote:
>>> On 2/24/22 12:01 PM, olcott wrote:
>>>> On 2/24/2022 10:55 AM, Richard Damon wrote:
>>>>> On 2/24/22 10:24 AM, olcott wrote:
>>>>>> On 2/24/2022 6:43 AM, Richard Damon wrote:
>>>>>>> On 2/23/22 11:31 PM, olcott wrote:
>>>>>>>> On 2/23/2022 9:36 PM, Richard Damon wrote:
>>>>>>>
>>>>>>>>> Then Analytic Truth is a sub-set of Truth. Just like the set of
>>>>>>>>> black cats doesn't contain all cats.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Yes it is yet it encompasses all of mathematics and logic.
>>>>>>>
>>>>>>> As I think back, I now remember on key fact that you are missing.
>>>>>>> Analytic Truth requires Proof in a Finite (or sometimes
>>>>>>> Enumerable) number of proof steps.
>>>>>>>
>>>>>>
>>>>>> The body of analytic truth is simply a set of true sentences that
>>>>>> are connected together semantically.
>>>>>>
>>>>>>> Mathematics introduces the concept of UnEnumeratable sets and
>>>>>>> this is what breaks the concept of Truth must be Provable. Some
>>>>>>> things can be shown true only by a 'meta-analysis' that looks at
>>>>>>> an uncountable number of Proof Steps, which Analytic Truth can
>>>>>>> not handle, thus it can establish facts that are not Analytically
>>>>>>> provable.
>>>>>>>
>>>>>>
>>>>>> This merely requires algorithmic compression. We can know that
>>>>>> there is no maximum integer without having to actually count to
>>>>>> infinity.
>>>>>
>>>>> But you can't compress ALL things. Your assupmtion that you can is
>>>>> a fallacy. For instance, you assume there must be a finite pattern
>>>>> that H can detect in its simulation of <H^> <H^> that correctly
>>>>> indicates that the pattern will repeat forever, when I have shown
>>>>> that no such pattern exists, as ANY pattern of N steps that H uses
>>>>> and then goes to H.Qn means that there IS a number K > N such that
>>>>> H^ applied to <H^> halts in K steps, thus H was wrong.
>>>>>
>>>>>>
>>>>>>> This also shows where you logic breaks down, you have show an
>>>>>>> inability to actually think about things that can become
>>>>>>> infinite. The problem with you H is that it actually needs
>>>>>>> infinite time to make a valid decision, but it needs to make it
>>>>>>> in a finite time, and thus it fails.
>>>>>>>
>>>>>>
>>>>>> That makes the utterly moronic assumption that the most
>>>>>> intelligent and knowledgeable person in the universe could not
>>>>>> possibly spot the infinite loop in the code shown below in less
>>>>>> then infinite time:
>>>>>>
>>>>>> _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]
>>>>>>
>>>>>>
>>>>>
>>>>> Fallacy of proof by example. FAIL.
>>>>>
>>>>> That pattern is NOT in H^ applied to <H^>.
>>>>>
>>>>> I never claimed that H couldn't detect SOME infinite loops,
>>>>
>>>> You claimed that H could not correctly report that the above is an
>>>> in finite loop because if H stops simulating it then it is no longer
>>>> an infinite loop.
>>>
>>>
>>> LIAR.
>>>
>>> I said it could not do it for H^ applied to <H^>
>>>
>>> Shows how much you understand the truth.
>> So you acknowledge that in the C/x86, H does correctly decide that
>> _Infinite_Loop() never halts ?
>>
>
> I don't know, because it has never been proven, just claimed.

_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 ?

--
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/24/2022 1:56 PM, Richard Damon wrote:
> On 2/24/22 2:39 PM, olcott wrote:
>> On 2/24/2022 12:51 PM, Richard Damon wrote:
>>> On 2/24/22 12:52 PM, olcott wrote:
>>>> On 2/24/2022 11:32 AM, Richard Damon wrote:
>>>>> On 2/24/22 12:01 PM, olcott wrote:
>>>>>> On 2/24/2022 10:55 AM, Richard Damon wrote:
>>>>>>> On 2/24/22 10:24 AM, olcott wrote:
>>>>>>>> On 2/24/2022 6:43 AM, Richard Damon wrote:
>>>>>>>>> On 2/23/22 11:31 PM, olcott wrote:
>>>>>>>>>> On 2/23/2022 9:36 PM, Richard Damon wrote:
>>>>>>>>>
>>>>>>>>>>> Then Analytic Truth is a sub-set of Truth. Just like the set
>>>>>>>>>>> of black cats doesn't contain all cats.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes it is yet it encompasses all of mathematics and logic.
>>>>>>>>>
>>>>>>>>> As I think back, I now remember on key fact that you are
>>>>>>>>> missing. Analytic Truth requires Proof in a Finite (or
>>>>>>>>> sometimes Enumerable) number of proof steps.
>>>>>>>>>
>>>>>>>>
>>>>>>>> The body of analytic truth is simply a set of true sentences
>>>>>>>> that are connected together semantically.
>>>>>>>>
>>>>>>>>> Mathematics introduces the concept of UnEnumeratable sets and
>>>>>>>>> this is what breaks the concept of Truth must be Provable. Some
>>>>>>>>> things can be shown true only by a 'meta-analysis' that looks
>>>>>>>>> at an uncountable number of Proof Steps, which Analytic Truth
>>>>>>>>> can not handle, thus it can establish facts that are not
>>>>>>>>> Analytically provable.
>>>>>>>>>
>>>>>>>>
>>>>>>>> This merely requires algorithmic compression. We can know that
>>>>>>>> there is no maximum integer without having to actually count to
>>>>>>>> infinity.
>>>>>>>
>>>>>>> But you can't compress ALL things. Your assupmtion that you can
>>>>>>> is a fallacy. For instance, you assume there must be a finite
>>>>>>> pattern that H can detect in its simulation of <H^> <H^> that
>>>>>>> correctly indicates that the pattern will repeat forever, when I
>>>>>>> have shown that no such pattern exists, as ANY pattern of N steps
>>>>>>> that H uses and then goes to H.Qn means that there IS a number K
>>>>>>> > N such that H^ applied to <H^> halts in K steps, thus H was wrong.
>>>>>>>
>>>>>>>>
>>>>>>>>> This also shows where you logic breaks down, you have show an
>>>>>>>>> inability to actually think about things that can become
>>>>>>>>> infinite. The problem with you H is that it actually needs
>>>>>>>>> infinite time to make a valid decision, but it needs to make it
>>>>>>>>> in a finite time, and thus it fails.
>>>>>>>>>
>>>>>>>>
>>>>>>>> That makes the utterly moronic assumption that the most
>>>>>>>> intelligent and knowledgeable person in the universe could not
>>>>>>>> possibly spot the infinite loop in the code shown below in less
>>>>>>>> then infinite time:
>>>>>>>>
>>>>>>>> _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]
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Fallacy of proof by example. FAIL.
>>>>>>>
>>>>>>> That pattern is NOT in H^ applied to <H^>.
>>>>>>>
>>>>>>> I never claimed that H couldn't detect SOME infinite loops,
>>>>>>
>>>>>> You claimed that H could not correctly report that the above is an
>>>>>> in finite loop because if H stops simulating it then it is no
>>>>>> longer an infinite loop.
>>>>>
>>>>>
>>>>> LIAR.
>>>>>
>>>>> I said it could not do it for H^ applied to <H^>
>>>>>
>>>>> Shows how much you understand the truth.
>>>> So you acknowledge that in the C/x86, H does correctly decide that
>>>> _Infinite_Loop() never halts ?
>>>>
>>>
>>> I don't know, because it has never been proven, just claimed.
>>
>> _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 ?
>>
>
> Again, the deceptive clipping of quotes.
>
> You asked me if I agreed your program could do this.
> > My answer was I wasn't sure because you have ever actually shown how you
> probram works, or even real proof that it does. My doubts are in your
> ability to program.
>

So you agree that it is trivial (once an x86 emulator has been provided)
to make a program that correctly reports the x86 emulation of the above
function would never halt ?

--
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/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.

> But the "infinite behaviour pattern" that your embedded_H is supposed to
> recognize doesn't remotely resemble the pattern above, so the fact that
> the above pattern can be trivially recognized provides *no* evidence
> that the pattern found in embedded_H can be algorithmically recognized
> whatsoever. Ergo, it is entirely pointless for you to keep raising this
> example. It is an entirely irrelevant example; a red herring.
>
> The "infinite recursion" you claim exists when embedded_H is applied to
> <H^> <H^> requires that your embedded_H be able to recognize that H^
> includes a copy of embedded_H within it, not just to find some instance
> of "HERE: goto HERE" like above.
>
> You've claimed that this can be done with string comparison, but to
> compare strings you need TWO STRINGS TO COMPARE. embedded_H only takes a
> SINGLE string (or rather two copies of a single string) as its input. So
> what exactly is it supposed to compare this string to?
>
> 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/24/2022 2:39 PM, André G. Isaak wrote:
> On 2022-02-24 13:33, 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.
>
> That is a separate issue, concerned with whether the infinite recursion
> you claim exists actually exists. My post wasn't concerned with that
> issue (though Richard is correct)
>

Until it is understood that embedded_H recognizing the infinitely nested
simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical impossibility I
have no motivation what-so-ever to proceed to any subsequent steps.

People that are only looking for one excuse or another to reject my work
and have interest at all in understanding what I am saying must
acknowledge each incremental step of mutual agreement before I will
proceed to any subsequent steps.

> Why not address the ACTUAL point of my post.

I just explained why.

> How exactly is your
> embedded_H supposed to recognize infinite recursion? Please elaborate on
> the 'string comparison' you claim is involved.
>
> André
>
>> 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.
>>
>>> But the "infinite behaviour pattern" that your embedded_H is supposed
>>> to recognize doesn't remotely resemble the pattern above, so the fact
>>> that the above pattern can be trivially recognized provides *no*
>>> evidence that the pattern found in embedded_H can be algorithmically
>>> recognized whatsoever. Ergo, it is entirely pointless for you to keep
>>> raising this example. It is an entirely irrelevant example; a red
>>> herring.
>>>
>>> The "infinite recursion" you claim exists when embedded_H is applied
>>> to <H^> <H^> requires that your embedded_H be able to recognize that
>>> H^ includes a copy of embedded_H within it, not just to find some
>>> instance of "HERE: goto HERE" like above.
>>>
>>> You've claimed that this can be done with string comparison, but to
>>> compare strings you need TWO STRINGS TO COMPARE. embedded_H only
>>> takes a SINGLE string (or rather two copies of a single string) as
>>> its input. So what exactly is it supposed to compare this string to?
>

--
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/24/2022 2:55 PM, Richard Damon wrote:
> On 2/24/22 3:33 PM, 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.
>
> The fact that you don't understand the difference between H needing to
> analyse a simple infinite loop, and H needing to analyse something that
> uses a copy of H in it, shows you just don't understand the problem.
>

The point is that I proved that your rebuttal is invalid on the basis of
the simpler example. When we apply your exact same reasoning to the
simpler example it becomes totally obvious that this reasoning is
incorrect.

> You seem oblivious that before you can even create the H^ to test H
> with, H has to be made into a fixed algorithm. with fully defined
> behavior. This means that the argument about what woud happen if H
> didn't abort at the point it does abort is irrelevent.

It is always the case that when-so-ever the input to a simulating halt
decider would cause the simulation to be infinite unless it was aborted
that the simulating halt decider correctly deciders that this input
never halts.

Because the above is true by logical necessity the strongest possible
rebuttal can only be of the form that you simply don't believe that it
is true.

--
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/24/2022 3:38 PM, André G. Isaak wrote:
> On 2022-02-24 13:56, olcott wrote:
>> On 2/24/2022 2:39 PM, André G. Isaak wrote:
>>> On 2022-02-24 13:33, 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.
>>>
>>> That is a separate issue, concerned with whether the infinite
>>> recursion you claim exists actually exists. My post wasn't concerned
>>> with that issue (though Richard is correct)
>>>
>>
>> Until it is understood that embedded_H recognizing the infinitely
>> nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical
>> impossibility I have no motivation what-so-ever to proceed to any
>> subsequent steps.
>
> But that is *exactly* the step I am asking you about below. I am asking
> you HOW your embedded_H recognizes infinitely nested recursion.

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⟩...

The above repeating pattern shows that the correctly simulated input to
embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
proving that this simulated input never halts.

If a TM cannot detect what is obvious for humans to see then the notion
of computation is artificially constrained and thus defined incorrectly.

> This is
> NOT the same problem as recognizing an infinite loop.
>
> So how *exactly* does embedded_H recognize when it is being simulated
> recursively?
>
> Put slightly differently, when you call embedded_H ⟨X⟩ ⟨X⟩ how does it
> distinguish between cases where X = Ĥ (i.e cases where X contains a copy
> of embedded_H) and cases where X does not equal Ĥ (i.e. cases which do
> not involve recursion)?
>
> String comparison won't work. So how do you achieve this?
>
> André
>
>> People that are only looking for one excuse or another to reject my
>> work   and have interest at all in understanding what I am saying must
>> acknowledge each incremental step of mutual agreement before I will
>> proceed to any subsequent steps.
>>
>>> Why not address the ACTUAL point of my post.
>>
>> I just explained why.
>>
>>> How exactly is your embedded_H supposed to recognize infinite
>>> recursion? Please elaborate on the 'string comparison' you claim is
>>> involved.
>>>
>>> André
>>>
>>>> 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.
>>>>
>>>>> But the "infinite behaviour pattern" that your embedded_H is
>>>>> supposed to recognize doesn't remotely resemble the pattern above,
>>>>> so the fact that the above pattern can be trivially recognized
>>>>> provides *no* evidence that the pattern found in embedded_H can be
>>>>> algorithmically recognized whatsoever. Ergo, it is entirely
>>>>> pointless for you to keep raising this example. It is an entirely
>>>>> irrelevant example; a red herring.
>>>>>
>>>>> The "infinite recursion" you claim exists when embedded_H is
>>>>> applied to <H^> <H^> requires that your embedded_H be able to
>>>>> recognize that H^ includes a copy of embedded_H within it, not just
>>>>> to find some instance of "HERE: goto HERE" like above.
>>>>>
>>>>> You've claimed that this can be done with string comparison, but to
>>>>> compare strings you need TWO STRINGS TO COMPARE. embedded_H only
>>>>> takes a SINGLE string (or rather two copies of a single string) as
>>>>> its input. So what exactly is it supposed to compare this string to?
>>>
>>
>>
>
>

--
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/24/2022 6:07 PM, Richard Damon wrote:
> On 2/24/22 6:41 PM, olcott wrote:
>> On 2/24/2022 3:38 PM, André G. Isaak wrote:
>>> On 2022-02-24 13:56, olcott wrote:
>>>> On 2/24/2022 2:39 PM, André G. Isaak wrote:
>>>>> On 2022-02-24 13:33, 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.
>>>>>
>>>>> That is a separate issue, concerned with whether the infinite
>>>>> recursion you claim exists actually exists. My post wasn't
>>>>> concerned with that issue (though Richard is correct)
>>>>>
>>>>
>>>> Until it is understood that embedded_H recognizing the infinitely
>>>> nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical
>>>> impossibility I have no motivation what-so-ever to proceed to any
>>>> subsequent steps.
>>>
>>> But that is *exactly* the step I am asking you about below. I am
>>> asking you HOW your embedded_H recognizes infinitely nested recursion.
>>
>> 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⟩...
>>
>> The above repeating pattern shows that the correctly simulated input
>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
>> proving that this simulated input never halts.
>>
>> If a TM cannot detect what is obvious for humans to see then the
>> notion of computation is artificially constrained and thus defined
>> incorrectly.
>>
>
> Except that the pattern only happens if H never aborts it simulation, at
> which point H has failed by not answering.
It is at this point on this issue that other reviewers such as {Kaz,
André and Mike} would understand that you are incorrect.

No matter what embedded_H does its simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot
possibly reach its own final state of ⟨Ĥ⟩.qn specifically because this
input specifies infinitely nested simulation to embedded_H.

These same reviewers would also understand that the fact that the
simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ cannot possibly reach its final state of ⟨Ĥ⟩.qn
meets the conventional definition of not halting (cannot reach a final
state).

--
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/24/2022 6:39 PM, André G. Isaak wrote:
> On 2022-02-24 16:41, olcott wrote:
>> On 2/24/2022 3:38 PM, André G. Isaak wrote:
>>> On 2022-02-24 13:56, olcott wrote:
>>>> On 2/24/2022 2:39 PM, André G. Isaak wrote:
>>>>> On 2022-02-24 13:33, 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.
>>>>>
>>>>> That is a separate issue, concerned with whether the infinite
>>>>> recursion you claim exists actually exists. My post wasn't
>>>>> concerned with that issue (though Richard is correct)
>>>>>
>>>>
>>>> Until it is understood that embedded_H recognizing the infinitely
>>>> nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical
>>>> impossibility I have no motivation what-so-ever to proceed to any
>>>> subsequent steps.
>>>
>>> But that is *exactly* the step I am asking you about below. I am
>>> asking you HOW your embedded_H recognizes infinitely nested recursion.
>>
>> 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⟩...
>>
>> The above repeating pattern shows that the correctly simulated input
>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
>> proving that this simulated input never halts.
>>
>> If a TM cannot detect what is obvious for humans to see then the
>> notion of computation is artificially constrained and thus defined
>> incorrectly.
>
> It is only obvious to a person who has a piece of information that the
> TM does not have; namely, that the string passed to Ĥ is a
> representation of Ĥ. You need to show how a TM can determine that its
> input string is a representation of *itself*. If you can't do this, your
> solution is unworkable.
>

Not until after you agree that embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ is correct when it
transitions to Ĥ.qn

> And your position that computations are 'defined incorrectly' is absurd.
> That's like claiming that since people can swim and cars cannot, cars
> are 'incorrectly defined'.
>

A theory T is incomplete if and only if there is some sentence φ such
that (T ⊬ φ) and (T ⊬ ¬φ).

The notion of incompleteness is defined incorrectly because it does not
screen out self-contradictory expressions of language.

> Computations aren't an attempt to model what people can or cannot do.
>
> 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/24/2022 6:39 PM, André G. Isaak wrote:
> On 2022-02-24 16:41, olcott wrote:
>> On 2/24/2022 3:38 PM, André G. Isaak wrote:
>>> On 2022-02-24 13:56, olcott wrote:
>>>> On 2/24/2022 2:39 PM, André G. Isaak wrote:
>>>>> On 2022-02-24 13:33, 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.
>>>>>
>>>>> That is a separate issue, concerned with whether the infinite
>>>>> recursion you claim exists actually exists. My post wasn't
>>>>> concerned with that issue (though Richard is correct)
>>>>>
>>>>
>>>> Until it is understood that embedded_H recognizing the infinitely
>>>> nested simulation of its input: ⟨Ĥ⟩ ⟨Ĥ⟩ is not a categorical
>>>> impossibility I have no motivation what-so-ever to proceed to any
>>>> subsequent steps.
>>>
>>> But that is *exactly* the step I am asking you about below. I am
>>> asking you HOW your embedded_H recognizes infinitely nested recursion.
>>
>> 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⟩...
>>
>> The above repeating pattern shows that the correctly simulated input
>> to embedded_H would never reach its final state of ⟨Ĥ⟩.qn conclusively
>> proving that this simulated input never halts.
>>
>> If a TM cannot detect what is obvious for humans to see then the
>> notion of computation is artificially constrained and thus defined
>> incorrectly.
>
> It is only obvious to a person who has a piece of information that the
> TM does not have; namely, that the string passed to Ĥ is a
> representation of Ĥ.

Therefore when embedded_H transitions to Ĥ.qn it has correctly reported
that its simulated input: ⟨Ĥ⟩ ⟨Ĥ⟩ would never reach 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/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.

--
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/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.

--
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/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]

--
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 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.

> You are just too dumb to understand.
>
> There is a FATAL flaw in your logic, and you are just going to DIE wrong.
>

So far all you have is rhetoric and have not pointed out a single error.

If you are really really motivated to provide a rebuttal and have no
interest what-so-ever in coming to a mutual agreement on any points then
all of your attempts at rebuttal cannot possibly be more than incoherent
double-talk.

> 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

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

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 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