XPost: comp.theory, sci.logic, sci.math

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

--- SoupGate-Win32 v1.05
* Origin: fsxNet Usenet Gateway (21:1/5)