Re: No decider is ever accountable for the behavior of the computation that itself is contained within (unless that is its input)

On 7/26/24 1: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
 [00002184][001037e1][001037e9] 83c404     add esp,+04
[00002187][001037e5][0000219f] 5d         pop ebp
[00002188][001037e9][00000000] c3         ret
[0000219f][001037e9][00000000] 33c0       xor eax,eax
[000021a1][001037ed][00000018] 5d         pop ebp
[000021a2][001037f1][00000000] c3         ret
Number of Instructions Executed(10071) == 150 Pages
 

So, where is the correct emulaiton of the input?
All you deiders just INCORRECTLY assume that HHH(DDD) will never return, which you prove to be incorrect.
So, you just prove your program is wrong.
3 is not "infinite", I guess you can't count very high because you are that stupid.