Re: I have always been incorrect about emulating termination analyzers --- PROOF

On 10/20/24 4:51 PM, olcott wrote:

On 10/20/2024 2:13 PM, Richard Damon wrote:

On 10/20/24 11:32 AM, olcott wrote:

On 10/20/2024 6:46 AM, Richard Damon wrote:

On 10/19/24 11:20 PM, olcott wrote:

On 10/19/2024 9:27 PM, Richard Damon wrote:

On 10/19/24 8:13 PM, olcott wrote:

>
You are directly contradicting the verified fact that DDD
emulated by HHH according to the semantics of the x86 language
cannot possibly reach its own "return" instruction and halt.
>

>
But that isn't what the question being asked

>
Sure it is. You are just in psychological denial as proven by
the fact that all attempted rebuttals (yours and anyone else's)
to the following words have been baseless.
>
Does the input DDD to HHH specify a halting computation?

>
Which it isn't, but is a subtle change of the actual question.
>
The actual question (somewhat informally stated, but from the source you like to use) says:
>
In computability theory, the halting problem is the problem of determining, from a description of an arbitrary computer program and an input, whether the program will finish running, or continue to run forever.
>

>
That is the problem. Because it is too informally stated
it can be misunderstood. No one ever intended for any
termination analyzer to ever report on anything besides
the behavior that its input actually specifies.

>
What is "informal" about the actual problem.
>
The informality is that it comes from a non-academic source, so doesn't use the formal terminology, which you just wouldn't understand.
>
What is to be misunderstood?
>
Given that you start with a program, which is defined as the fully detailed set of deterministic steps that are to be performed, and that such a program, will do exactly one behavior for any given input given to it, says that there is, BY DEFINITIOH a unique and specific answer that the analysize must give to be correct.
>
The requirement says that the user needs to, by the rules defined by the analyszer, describe that program, and if the analyzer is going to be able to qualify, must define at least one way (but could be multiple) of creating the proper description of that input program, and that an given input that meets that requirement will exactly represent only a singe equivalence set of programs (an equivalence set of programs is a set of programs that all members always produce the same output results for every possible input). Thus, there must exist a unique mapping from each input to such an equivalence set to a correct answer.
>
Thus, it is THAT BEHAVIOR, the behavior of the full program that *IS* the behavior that its input actually specifies.
>
WHAT IS WRONG WITH THAT?
>
>
Now, this does point out that you claim of what could be the "finite- string input" for you HHH, can't possible be such a correct input,
>

>

So, DDD is the COMPUTER PROGRAM to be decided on,

>
No not at all. When DDD is directly executed it specifies a
different sequence of configurations than when DDD is emulated
by HHH according to the semantics of the x86 language.

>
And what step actually correctly emulated created the first difference in sequence?
>

 When the directly executed DDD() calls HHH(DDD) this
call does return and DDD halts.
 When DDD emulated by HHH according to the semantics of the x86
language calls HHH(DDD) this call cannot possibly does return
thus emulated DDD cannot possibly halt.
 

But, since that emulation was aborted, it doesn't say that the behavior of the input is to never terminate.
PARTIAL correct emulations, which is what you are talking about don't provide that property.
If you want get that property, you need to use a COMPLETE correct emulation, which HHH doesn't do, so your statement is just in error.
You are just proving that your idea of logic is based on lying via equivocation.
Sorry, but that is just the facts as you show it.