Re: D correctly simulated by H proved for THREE YEARS --- finite string transformation rules

On 6/12/24 12:50 PM, olcott wrote:

On 6/12/2024 6:33 AM, Richard Damon wrote:

On 6/11/24 11:34 PM, olcott wrote:

On 6/11/2024 9:32 PM, Richard Damon wrote:

On 6/11/24 8:57 PM, olcott wrote:

On 6/11/2024 7:20 PM, Python wrote:

Le 12/06/2024 à 01:23, olcott a écrit :
...

It turns out that by the generic definition of a decider
what the directly executed D(D) does is not any of the
business of H.

>
LOL
>

>
There are no finite string transformations from the input
to H to the behavior of D(D), thus the behavior of D(D)
is irrelevant.
>

>
Of course there is.
>
That is exactly what the definition of a UTM is.
>

>
Unless we are as concrete as the x86 language truth slips
though the cracks of vagueness.
>
Show each step of DDD correctly simulated by HH such that
DDD terminates normally.

>
WHy? I never claimed that to be true.
>
The lack of finding a couter example doesn't prove that no counter example exists, it might just not be discovered.
>

 On 5/29/2021 2:26 PM, olcott wrote:
https://groups.google.com/g/comp.theory/c/dTvIY5NX6b4/m/cHR2ZPgPBAAJ
 *This is still Truthmaker Maximalism*
The actual behavior of the input to H(D,D) is the truthmaker
for halt decider H.

Which is DEFINED to be the behavior of the program described by the input when directly run.

 When we compute the mapping from the input to H(D,D) this
must apply a set of finite string transformation rules
(specified by the semantics of the x86 language) to this input.

No, we apply the DEFINTION of the problem that H is claiming to solve.
The finite-string transformation that does this is an actual UTM.

 The appropriate finite string transformation rules are D
correctly simulated by H.

Then H just is NOT a Halt Decider, and you are just admitting to LYING about that for the last decades, as the transformation rules are that of a the UTM.
Unles you can provide a RELAIBLE SOURCE for your claim that it is "the correct simulation by H", you are just admitting that you have been a LIAR for this for the past decades.

 There is no mapping from the input to H(D,D) to the behavior
of D(D). If there was such a mapping then the detailed steps
of D correctly simulated by H where D terminates normally
could be provided.

Of course there is, that is what a UTM does.
But since HB isn't a UTM, your claim just show you to be a lying idiot.
Can you show a reference that the transformation needs to be something done by a particular decider?
Failure to provide that also prove you to be just a idiotic pathological liar.

 Thus I have proven H(D,D) is not allowed to report on the
behavior of the directly executed D(D) because H is required
to report on the mapping form its input and there is no mapping
that reaches the behavior of D(D).
>

Nope, you have shown that you think "unsubstantiated claim" make up a proof.
Thus showing you are totally UNqualified to be discussing logic.

_D()
[00000cfc](01) 55          push ebp
[00000cfd](02) 8bec        mov ebp,esp
[00000cff](03) 8b4508      mov eax,[ebp+08]
[00000d02](01) 50          push eax       ; push D
[00000d03](03) 8b4d08      mov ecx,[ebp+08]
[00000d06](01) 51          push ecx       ; push D
[00000d07](05) e800feffff  call 00000b0c  ; call H
[00000d0c](03) 83c408      add esp,+08
[00000d0f](02) 85c0        test eax,eax
[00000d11](02) 7404        jz 00000d17
[00000d13](02) 33c0        xor eax,eax
[00000d15](02) eb05        jmp 00000d1c
[00000d17](05) b801000000  mov eax,00000001
[00000d1c](01) 5d          pop ebp
[00000d1d](01) c3          ret
Size in bytes:(0034) [00000d1d]