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

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 2/24/22 10:14 AM, olcott wrote:
> On 2/24/2022 6:12 AM, Richard Damon wrote:
>> On 2/23/22 11:31 PM, olcott wrote:
>>> On 2/23/2022 9:36 PM, Richard Damon wrote:
>>> Yes it is yet it encompasses all of mathematics and logic.
>>> It only excludes those things that rely on sense data from the sense
>>> organs to be validated. All cats are animals is analytic. There is no
>>> cat in my living room right now is synthetic.
>>
>> If it insists that All Truth is Provable, it does NOT. That is what
>> Godel proved.
>
> All Truth is provable his sentence simply was not true.
>
>>
>> Godel sentence is an actual Truth Bearing Statement, just like the
>> pair of statements of the 3x+1 problem.
>>
>> Statement P must be True or it is False.
>
> That is a false assumption.
>
>> If statement P is True, then by its statement P is Unprovable, and
>> thus no proof of it can exist.
>>
>> If Statement P is false, then its converse is true, that that means
>> that P must be Provable. But it P is Provable, then either P must be
>> True, or the logic system has gone inconsistent.
>>
>> Thus, we MUST conclude that P is unprovable, and thus some truths are
>> not provable.
>>
>
> there is also a close relationship with the “liar” antinomy,14 ...
> We are therefore confronted with a proposition which asserts its own
> unprovability.15 ...
> 14 Every epistemological antinomy can likewise be used for a similar
> undecidability proof. (Gödel:1931:40)
>
> These two self contradictory sentences are isomorphic:
> This sentence is not true.
> This sentence is not provable.
>
> Gödel, Kurt 1931. On Formally Undecidable Propositions of Principia
> Mathematica And Related Systems I, page 39-41.
>
> https://mavdisk.mnsu.edu/pj2943kt/Fall%202015/Promotion%20Application/Previous%20Years%20Article%2022%20Materials/godel-1931.pdf
>
>
>>>
>>>>>
>>>>>>>>
>>>>>>>> Moreover, it also doesn't follow from your above claim that
>>>>>>>> "When you start with truth and only apply truth preserving
>>>>>>>> operations you always necessarily end up with truth." So you're
>>>>>>>> basically presenting a non-sequitur.
>>>>>>>>
>>>>>>>
>>>>>>> Something that 100% perfectly logically follows is utterly
>>>>>>> ridiculously characterized as non-sequitur.
>>>>>>
>>>>>> If you think the latter follows from the former you then you need
>>>>>> a course in remedial logic.
>>>>>
>>>>> If you start with expressions of language that are known to be true
>>>>> (such as Haskell Curry's elementary theorems) and only apply truth
>>>>> preserving operations you don't end up with peanut butter.
>>>>
>>>> But you also do get you all Truths.
>>>
>>> You get the entire body of analytic truth.
>>
>> You still are missing the fact that while analysis can show you what
>> is provable, and thus many things that are True, it has been shown
>> that there exists Truths that can not be proven. And that Mathematics
>> includes such Truths.
>>
>
> A theory T is incomplete if and only if there is some sentence φ such
> that (T ⊬ φ) and (T ⊬ ¬φ).
>
> This is simply a misconception that comes from stripping semantics away
> from classical and symbolic logic relative to Aristotle's syllogism.
> https://en.wikipedia.org/wiki/Syllogism#Basic_structure
>
> The above sentence defines the notion of incomplete never realizing that
> some sentences are neither provable nor unprovable only because they are
> self-contradictory.
>
> there is also a close relationship with the “liar” antinomy,14 ...
> We are therefore confronted with a proposition which asserts its own
> unprovability.15 ...
> 14 Every epistemological antinomy can likewise be used for a similar
> undecidability proof. (Gödel:1931:40)
>
> These two self contradictory sentences are isomorphic:
> This sentence is not true.
> This sentence is not provable.
>
>
>
>>>
>>>>>
>>>>>>>
>>>>>>>>  > in the same way that the following sentence is neither true
>>>>>>>> nor false:
>>>>>>>>  > "What time is it?"
>>>>>>>>
>>>>>>>> That sentence is not a proposition. Gödels paper is concerned
>>>>>>>> with undecidable *propositions*. And it isn't concerned with
>>>>>>>> natural language at all.
>>>>>>>>
>>>>>>>
>>>>>>> I wanted to make a very clear example of an expression of
>>>>>>> language that very obviously cannot be resolved to true or false.
>>>>>>> Example form formal language that are not truth bearers are
>>>>>>> placed in the incorrect category of undecidable.
>>>>>>
>>>>>> There is no category in formal systems analogous to interrogatives.
>>>>>
>>>>> There is one yet not one that you are aware of.
>>>>>
>>>>> This is not my idea:
>>>>> Questions are merely propositions with a missing piece.
>>>>>
>>>>>> You seem to not grasp the distinction between ontology and
>>>>>> epistemology. Whether we can *determine* whether a statement is
>>>>>> true or false is an epistemological issue which has no bearing at
>>>>>> all on whether the statement actually *is* true or false.
>>>>>>
>>>>>
>>>>> In computer science and information science, an ontology
>>>>> encompasses a representation, formal naming, and definition of the
>>>>> categories, properties, and relations between the concepts, data,
>>>>> and entities that substantiate one, many, or all domains of discourse.
>>>>> https://en.wikipedia.org/wiki/Ontology_(information_science)
>>>>>
>>>>>>> Flibble is correct in that the reason these things are not
>>>>>>> properly resolved is category error. When one assumes a
>>>>>>> term-of-the-art definition that has hidden incoherence then these
>>>>>>> terms-of-the-art make their own error inexpressible.
>>>>>>>
>>>>>>> The strong version, or linguistic determinism, says that language
>>>>>>> determines thought and that linguistic categories limit and
>>>>>>> determine cognitive categories.
>>>>>>> https://en.wikipedia.org/wiki/Linguistic_relativity
>>>>>>
>>>>>> Both a mischaracterization and utterly irrelevant.
>>>>>>
>>>>>
>>>>> A theory T is incomplete if and only if there is some sentence φ
>>>>> such that (T ⊬ φ) and (T ⊬ ¬φ).
>>>>>
>>>>> The above simply ignores the case where a syntactically correct
>>>>> expression of a formal language is unprovable simply because at the
>>>>> semantic level it is self-contradictory.
>>>>
>>>> Except the problem in question is NOT self-contradictory, which you
>>>> don't understand.
>>>>
>>>
>>> "This sentence is not true" is indeed not true yet this does not make
>>> it true because it is self-contradictory.
>>
>> But that is NOT the Godel Sentence.
>
> Gödel says that it is close enough:
>
> there is also a close relationship with the “liar” antinomy,14 ...
> We are therefore confronted with a proposition which asserts its own
> unprovability.15 ...
> 14 Every epistemological antinomy can likewise be used for a similar
> undecidability proof. (Gödel:1931:40)

Related does not mean the same.

He is pointing out that any form that creates an antinomy can be
transformed by changing it from asserting about truth to asserting about
provability, into this form.

Since Truth and Provable are NOT the same thing, this makes it different.

>
> He also says that even the liar paradox derives his same results.

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

If H aborts its simulation after N cycles, then H^ only goes through N+1
cycles, then its embedded copy of H aborts its simulation, and H^ goes
to H^.Qn and Halts, and thus H is wrong.

Until you show an actual machine that acts differently when embedded as
you embedded_H has been, you are just playing with Fairy Dust Powered
Unicorns.

FAIL

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

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

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

Computations aren't an attempt to model what people can or cannot do.

André

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

On 2022-02-24 17:28, olcott wrote:
> On 2/24/2022 6:07 PM, Richard Damon wrote:

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

Please don't presume to know what I think.

Andree

--
To email remove 'invalid' & replace 'gm' with well known Google mail
service.

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/22 7:28 PM, olcott wrote:
> 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.

But it isn't 'embedded_H's simulation that matters. It is UTM <H^>
<H^>'s simulation that matters.

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

Except that the CORRECTLY simulated version lf <H^> <H^> DOES get to
H^.Qn if H <H^> <H^> goes to H.Qn, and you even sort of admit to it,
since you argree that H^ applied to <H^> get there.

Since the CORRECT simulation of <H^> <H^> BY DEFINITION does the same
thing as H^ <H^>, the CORRECT simulation also goes to H^.Qn.

The fact that H's simulation doesn't get there doesn't matter.

As has been pointed out, you need to decide which H we are talking about.

For Hn that doesn't abort, you are correct that Hn^ <Hn^> doesn't reach
Hn^.Qn but then Hn doesn't get to H.Qn either, so H is wrong for not
giving an answer.

For Ha that does abort its simulation of <Ha^> <Ha^> and go to Ha.Qn,
then we have shown that Ha^ <Ha^> also goes to Ha^.Qn and Halts, and
since the behavior of Ha^ applied to <Ha^> defines the right answer for
H <Ha^> <Ha^> we see that H was wrong.

You conflate you machines and seem to be talking about the computaiton
of Ha <Hn^> <Hn^> which is NOT the needed computation, yes Ha gets the
right answer, but that isn't the computation that Linz specifies.

SO FAIL.

On 2/24/22 7:44 PM, olcott wrote:
> 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

Since it isn't, that isn't a good condition.

Remember the definition:

H <M> w needs to go to H.Qn IF AND ONLY IF M applied to w never Halts.

If H <H^> <H^> goes to H.Qn, then the H^ <H^> that this H is embedded in
go at the exact same instant to H^.Qn (as its mapped state) and Halts.

Since H <H^> <H^> maps by M = H^, w = <H^> to the above definition, and
the specified machine Halted, H was NOT correct in going to H.Qn

Thus YOU LIE about it being correct, and show off your ignorance.

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

You don't get to redefine termss. That is just being a LIAR.

Note that the Halting Problem is NOT self-contradictory.

Halts(H^ applied to <H^>) has a fully defined value for any H you want
to actually define, thus it IS a Truth Bearer.

The fact that no H can return the right value isn't a problem.

Your problem is you never get arround to actually locking in a definiton
for you H to test it, but keep on having two DIFFERENT machine you
confuse with eash other, the Hn and Ha that do not and do abort. Until
you actually choose your H, you can't build the H^ to test.

FAIL

>> Computations aren't an attempt to model what people can or cannot do.
>>
>> André
>>
>>
>
>

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.

On 2/24/2022 6:41 PM, André G. Isaak wrote:
> On 2022-02-24 17:28, olcott wrote:
>> On 2/24/2022 6:07 PM, Richard Damon wrote:
>
>>> 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.
>
> Please don't presume to know what I think.
>
> Andree
>

I am saying that you would understand that he is incorrect about this
specific issue, not that you would acknowledge this understanding.

--
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/22 8:15 PM, olcott wrote:
> On 2/24/2022 6:41 PM, André G. Isaak wrote:
>> On 2022-02-24 17:28, olcott wrote:
>>> On 2/24/2022 6:07 PM, Richard Damon wrote:
>>
>>>> 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.
>>
>> Please don't presume to know what I think.
>>
>> Andree
>>
>
> I am saying that you would understand that he is incorrect about this
> specific issue, not that you would acknowledge this understanding.
>

Except that I sespect that He, as EVERYONE else you mentioned, would
agree with me that the pattern you mention doesn't occur if H aborts its
simulation.

Your persumption is just one of the ways you LIE, and make a false
appeal to Authority. (It is really bad when the 'Authority' you appeal
to corrects you and points out that the did think what you claim they
thought).

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.

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

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?

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.

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

You have therefore really lost the right to complain about others doing
the same to you.

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

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.

This is ridiculous.

On 2/24/2022 9:38 PM, Python wrote:
> 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.
>
> This is ridiculous.
>

Are you a bot?

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

If H^ does this pattern forever, then NO embedded_H can ever abort it
simulation, or the pattern does NOT go on forever.

Simple words that even YOU should be able to understand it:

Starting at this line:

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

Then if any H / embedded_H will abort is simulation and go to H.Qn, then
this embedded_H just mentioned, since it is given the exact same input
will do the same, and thus after it does whatever level of simulation it
will do, it will abort its simulation and go to its H.Qn which mappes to
H^.Qn for the H^ <H^1> that feed embedded_H the <H^1> <H^2>. and then
this H^ will Halt.

Since this shows that H^ <H^> Halts, ALL copies of H^ applied to <H^>
will halt in exactly the same period of time, and thus UTM <H^> <H^>
will also halt after simulating that same number of steps and thus the
pattern NEVER repeated forever, and the correct answer was Halting.

Thus, the ONLY case where you actually DO get that infinite pattern is
if the algorithm in H actually doesn't abort its simulation, and thus
ALL copies of H / embedded_H will do this loop forever and fail to
transition to H.Qn to give the correct answer.

This has been explained to you enough times that the only explaination
for you not understanding it is that either you are brain damaged and
undable to understand simple logic, or you are just a pathological liar
and don't care about the Truth, and have condemened yourself to an
eternity of disgrace.

There is nothing wrong with the concept of a 'Simulating Halt Decider',
it is just still under the exact same rules as any other Halt Decider,
and thus still can't give the right answer to this case as it is just
impossible.

If you want to claim that some H abort their simulation, but the
identical copy of the algorithm in embedded_H doesn't then you need to
provide an actual Turing Machine to prove your impossible claim (and
make yourself famous) otherwise you are just talking about Fairy Dust
Powered Unicorns.

FAIL.

olcott wrote:
> On 2/24/2022 9:38 PM, Python wrote:
>> 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.
>>
>> This is ridiculous.
>>
>
> Are you a bot?

I'm not. You became one.

This is sad, given you conditon.

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

FAIL.

Please supply that actual pattern that you plan on using and show an
actual trace of the running of H^ <H^> (or UTM <H^> <H^>) with the
embedded_H that is embedded into tha top level H^ using that pattern.

You will see that if H applied to <H^> <H^> goes to H.Qn to indicate
that it THINKS the comutation is non-halting, that the actual computaton
H applied to <H^> will halt as its embedded_H will abort its simulation
just slightly after the point that your H stop simulating and go to H.Qn
which causes the H^ to go to H^.Qn and Halt.

Thus, since the DEFINITION of the correct behavior of H is that H <M> w
only goes to H.Qn if M applied to w never halts, and since by the
parameter matching of M == H^ and w == <H^> means that H <H^> <H^>
should only go to H.Qn if H^ applied to <H^> never halts, but it does
halt, that H failed to meet its requirements.

If you want to claim the embedded_H behaves differently than H, please
provide a machine that can actually demonstart that and become famous,
otherwise you ar just shown to be a pathological liar who depends on
Fairy Dust Powered Unicorns to make your arguments work.

FAIL.