Path: ...!weretis.net!feeder9.news.weretis.net!news.nk.ca!rocksolid2!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: I have always been correct about emulating termination analyzers
 --- PROOF
Date: Sun, 20 Oct 2024 15:13:36 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <b8862132632732d17892186510c3f0ca2a459755@i2pn2.org>
References: <ves6p1$2uoln$1@dont-email.me>
 <3232d8a0cc7b5d4bba46321bf682c94573bf1b7c@i2pn2.org>
 <vesemu$2v7sh$1@dont-email.me>
 <a9fb95eb0ed914d0d9775448c005111eb43f2c5b@i2pn2.org>
 <veslpf$34ogr$1@dont-email.me>
 <647fe917c6bc0cfc78083ccf927fe280acdf2f9d@i2pn2.org>
 <vetq7u$3b8r2$1@dont-email.me>
 <522ecce215e636ddb7c9a1f75bff1ba466604cc5@i2pn2.org>
 <veuvt9$3hnjq$1@dont-email.me>
 <87634d01e18903c744d109aaca3a20b9ce4278bb@i2pn2.org>
 <vev8gg$3me0u$1@dont-email.me>
 <eb38c4aff9c8bc250c49892461ac25bfccfe303f@i2pn2.org>
 <vf051u$3rr97$1@dont-email.me>
 <e3f28689429722f86224d0d736115e4d1895299b@i2pn2.org>
 <vf1hun$39e3$1@dont-email.me>
 <dedb2801cc230a4cf689802934c4b841ae1a29eb@i2pn2.org>
 <vf1stu$8h0v$1@dont-email.me>
 <592109c757262c48aaca517a829ea1867913316b@i2pn2.org>
 <vf37qt$fbb3$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sun, 20 Oct 2024 19:13:36 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="2925119"; mail-complaints-to="usenet@i2pn2.org";
	posting-account="diqKR1lalukngNWEqoq9/uFtbkm5U+w3w6FQ0yesrXg";
User-Agent: Mozilla Thunderbird
X-Spam-Checker-Version: SpamAssassin 4.0.0
Content-Language: en-US
In-Reply-To: <vf37qt$fbb3$1@dont-email.me>
Bytes: 14197
Lines: 286

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?

You have been asked this many times, and just fail to answer, because 
your claim has just been proven to be a *LIE*, so of course you can't 
find a proof for it,

> 
> On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
>  > ... PO really /has/ an H (it's trivial to do for this one case)
>  > that correctly determines that P(P) *would* never stop running
>  > *unless* aborted.

But that is just admitting that your HHH isn't answering the HALTING 
PROBLEM, but the POOP problem, which has a different domain

> 
> That everyone has always believed that a termination analyzer
> must report on behavior that it does not see is the same sort
> of mistake as believing that a set can be a member of itself.
> Eliminate the false assumption and the issue is resolved.

There was NEVER a requirement that the termination analyser be able to 
"see" the answer. That is part of the question. If it COULD always see 
the behavior in question, then the question would be computable.

The fact that it is impossible to build a decider, like H that can 
actually see the correct answer for D, is what shows that Halting is 
non-computable.

Flibble has shown a method that you could use to build an HHH that is 
given the DDD that calls it, and correctly determines the answer, by 
dividing the problem into two cases and see if either of them work out.

Thus DDD is not a "pathological input" for a smart enough termination 
analyzer, working in the non-turing complete space defined by your 
environment structure, but that case is "computable".

It is only when we go to the original D/P that does the opposite of what 
H returns, that we find that we can not answer, and at least that 
machine was able to figure that case out as being unsolvable.

> 
>> and is converted to a DESCRIPTION of that program to be the input to 
>> the decider, and THAT is the input.
>>
>> So, the question has ALWAYS been about the behavior of the program (an 
>> OBJECTIVE standard, meaning the same to every decider the question is 
>> posed to).
>>
> 
> Then it is the same error as a set defined as a member of itself.
> The ZFC resolution to Russell's Paradox sets the precedent that
> discarding false assumptions can be a path to a solution.
> 

Nope. While a turing machine can not contain a "copy" of itself within 
it (as that would lead to an infinite machine from the nesting), there 
is no problem with giving a machine as an input a description of a 
machine that contains a copy of itself.

This is part of what leads to uncomputable questions, but that isn't the 
same type of error as the illogical contradictions from the rules 
allowing sets to contain themselves.

There is no "false assumption" to be discarded, and you have done 
NOTHING to attempt to try to show one.

>>> (where a halting computation is defined as)
>>>
>>> DDD emulated by HHH according to the semantics of the x86
>>> language reaches its own "return" instruction final state.
>>
>> Except that isn't the definition of halting, as you have been told 
>> many times, but apparently you can't undetstand.
>>
> 
> Sure and if everyone stuck with the "we have always done it that way
> therefore you can't change it" ZFC would have been rejected out-of-hand
> and Russell's Paradox would remain unresolved.

Which means you just don't understand how Formal Systems work.

The Halting Problem is PROVEN to be uncomputable in the Computation 
Theory of Turing Complete computations.
========== REMAINDER OF ARTICLE TRUNCATED ==========