Re: H(D,D) cannot even be asked about the behavior of D(D) --- Boilerplate Reply

On 6/21/24 12:01 AM, olcott wrote:

On 6/20/2024 10:52 PM, Richard Damon wrote:

On 6/20/24 11:30 PM, olcott wrote:

On 6/20/2024 9:59 PM, Richard Damon wrote:

On 6/20/24 10:46 PM, olcott wrote:

On 6/20/2024 9:38 PM, Richard Damon wrote:

On 6/20/24 10:04 PM, olcott wrote:

On 6/20/2024 8:55 PM, Richard Damon wrote:

On 6/20/24 11:04 AM, olcott wrote:

On 6/20/2024 9:42 AM, Mikko wrote:

On 2024-06-20 05:15:37 +0000, olcott said:
>

On 6/20/2024 12:04 AM, Mikko wrote:

>

Sitll inclear whether you know what "termination analyzer" means.

>

I really don't care what you believe.
It is not about belief.
It is about correct reasoning.

>
No, it is not. It is about language maintenance. If you cannot present
your reasoning in Common Language it does not matter whether your
reasoning is correct.
>

>
I cannot possibly present my reasoning in a convincing way
to people that have already made up their mind and closed it
thus fail to trace through each step of this reasoning looking
for an error and finding none.

>
BNo, we are open to new ideas that have an actual factual
>

>
If you simply leap to the false assumption that I am wrong
yet fail to point out any mistake because there are no mistakes
this will only convince gullible fools that also lack sufficient
technical competence.
>

>
We don't leap from false assumption, we start with DEFINTIONS.
>

>
When it is defined that H(D,D) must report on the behavior
of D(D) yet the finite string D cannot be mapped to the
behavior of D(D) then the definition is wrong.
>
*You seem to think that textbooks are the word of God*
>

>
>
Why do you say it can not be "mapped"
>
Of course it can be mapped by the definition of mapping that decider are supposed to use, as
>

>
You need to show every single freaking step of exactly
DDD correctly emulated by HH0 reaches past its own
machine address [0000209b] or all you have is BULLSHIT!

>
>
No, all *YOU* have is BULL-POOP in your head, as NOWHERE, but in your POOP-filled brain, is there any requirement that the mapping is defined by the steps of the decider. You just have the problem BACKWARDS, like most of your logic.
>

>
_DDD()
[00002093] 55               push ebp
[00002094] 8bec             mov ebp,esp
[00002096] 6893200000       push 00002093 ; push DDD
[0000209b] e853f4ffff       call 000014f3 ; call HH0
[000020a0] 83c404           add esp,+04
[000020a3] 5d               pop ebp
[000020a4] c3               ret
Size in bytes:(0018) [000020a4]
>
There is no mapping to the behavior of DDD correctly emulated
by any x86 emulator based decider that can possibly exist to
the behavior of DDD that reaches past its own machine address
[0000209b] *you have always know this and lied about it*
>
*I truly hope you repent. I don't want you to be condemned to Hell*
>

>
It doesn't need to be simulated by the decider!
>

 That is the only definitive way to determine the
actual behavior that the finite string specifies.
 

It is the only was to COMPUTE the actual behavior, but to DETERMINE it doesn't need that.
Your problem is you don't have the right definition of TRUTH, so none of your logic works.
Remember, Truth can be established by an infinite number of steps in the system. We can determine it is true, if we find a meta-system for that system which allows an induction or similar operation that allows us to convert that infinte chain in the system to something finite.
Thus, for DDD, we can use logic that says that *IF* HH0(DDD) returns an answer, then DDD *WILL* halt.
So, HH0(DDD) returning 0 can not be correct.
In system, with a specific definition of HH0, we can prove this in a finite number of steps by just running the execution of DDD, and stepping though every step of HH0 simulating the input it was given, and then eventually giving up and returning to DDD and halting.
In a meta-system, we can argue about ALL HH0's with different classes of results, and prove more general cases.
So, no it isn't the only difinitive way to determine the actual behavior (that is the simulation of DDD by HH0), we can simulate that DDD using a particular HH0 with a real correct simulator and get the behavior,
Remember, only PROGRAMS have this sort of behavior, and thus the HH0 that DDD is tied to is part of the definition of DDD when we ask about its halting behavior,