Re: No decider is ever accountable for the behavior of the computation that itself is contained within

Op 26.jul.2024 om 19:29 schreef olcott:

On 7/26/2024 12:09 PM, olcott wrote:

On 7/26/2024 11:28 AM, olcott wrote:

No decider is ever accountable for the behavior of the
computation that itself is contained within.
>
It is only accountable for computing the mapping from the
input finite string to the actual behavior that this finite
string specifies.
>
typedef void (*ptr)();
int HHH(ptr P);
>
void DDD()
{
   HHH(DDD);
}
>
int main()
{
   DDD();
}
>
HHH(DDD) is only accountable for the actual behavior that
its input specifies and is not accountable for the behavior
of the computation that itself is contained within:
the directly executed DDD();
>
When Ĥ is applied to ⟨Ĥ⟩
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
(a) Ĥ copies its input ⟨Ĥ⟩
(b) Ĥ invokes embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(c) embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(d) simulated ⟨Ĥ⟩ copies its input ⟨Ĥ⟩
(e) simulated ⟨Ĥ⟩ invokes simulated embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
(f) simulated embedded_H simulates ⟨Ĥ⟩ ⟨Ĥ⟩
(g) goto (d) with one more level of simulation
>
Two complete simulations show a pair of identical TMD's are
simulating a pair of identical inputs.  We can see this thus
proving recursive simulation.
>
When we understand that embedded_H is accountable for the
behavior of its input and not accountable for the behavior
of the computation that itself is contained within then
we understand that embedded_H is necessarily correct to
transition to its own Ĥ.qn state.
>
https://www.liarparadox.org/Linz_Proof.pdf
>
>

_DDD()
[00002177] 55               push ebp
[00002178] 8bec             mov ebp,esp
[0000217a] 6877210000       push 00002177 ; push DDD
[0000217f] e853f4ffff       call 000015d7 ; call HHH
[00002184] 83c404           add esp,+04
[00002187] 5d               pop ebp
[00002188] c3               ret
Size in bytes:(0018) [00002188]
>
_main()
[00002197] 55               push ebp
[00002198] 8bec             mov ebp,esp
[0000219a] e8d8ffffff       call 00002177 ; call DDD
[0000219f] 33c0             xor eax,eax
[000021a1] 5d               pop ebp
[000021a2] c3               ret
Size in bytes:(0012) [000021a2]
>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  =========  =============
[00002197][001037e9][00000000] 55         push ebp
[00002198][001037e9][00000000] 8bec       mov ebp,esp
[0000219a][001037e5][0000219f] e8d8ffffff call 00002177 ; call DDD
[00002177][001037e1][001037e9] 55         push ebp
[00002178][001037e1][001037e9] 8bec       mov ebp,esp
[0000217a][001037dd][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][001037d9][00002184] e853f4ffff call 000015d7 ; call HHH
>

 

// executed HHH emulates 1st instance of DDD
New slave_stack at:10388d
Begin Local Halt Decider Simulation   Execution Trace Stored at:113895
[00002177][00113885][00113889] 55         push ebp
[00002178][00113885][00113889] 8bec       mov ebp,esp
[0000217a][00113881][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0011387d][00002184] e853f4ffff call 000015d7 ; call HHH
>
// emulated HHH emulates 2nd instance of DDD
New slave_stack at:14e2b5
[00002177][0015e2ad][0015e2b1] 55         push ebp
[00002178][0015e2ad][0015e2b1] 8bec       mov ebp,esp
[0000217a][0015e2a9][00002177] 6877210000 push 00002177 ; push DDD
[0000217f][0015e2a5][00002184] e853f4ffff call 000015d7 ; call HHH
Local Halt Decider: Infinite Recursion Detected Simulation Stopped
>

 The above has the same behavior pattern as infinite recursion
shown below.
 void Infinite_Recursion()
{
   Infinite_Recursion();
}

No, it has the same behaviour pattern as Finite_Recursion:
void Finite_Recursion (int N) {
   if (N > 0) Finite_Recursion (N - 1);
}
But HHH (and probably olcott as well) thinks that two recursions are enough to prove an infinite recursion.
No matter how much olcott wants it to be correct, or how many times olcott repeats that it is correct, it does not change the fact that such a simulation is incorrect, because it is unable to reach the end.