Re: DDD simulated by HHH cannot possibly halt (Halting Problem)

On 4/7/25 10:40 PM, olcott wrote:

On 4/7/2025 5:51 AM, Richard Damon wrote:

On 4/7/25 12:28 AM, olcott wrote:

On 4/6/2025 11:25 AM, Richard Damon wrote:

On 4/6/25 12:12 PM, olcott wrote:

On 4/6/2025 5:27 AM, Mikko wrote:

On 2025-04-05 16:45:28 +0000, olcott said:
>

On 4/5/2025 2:05 AM, Mikko wrote:

On 2025-04-05 06:18:06 +0000, olcott said:
>

On 4/4/2025 3:12 AM, Mikko wrote:

On 2025-04-04 01:27:15 +0000, olcott said:
>

void DDD()
{
    HHH(DDD);
    return;
}
>
Do you really think that anyone knowing the C
programming language is too stupid to see that
DDD simulated by HHH cannot possibly return?

>
Anyone knowing the C language can see that if DDD() does not halt
it means that HHH(DDD) does not halt. The knowledge that that
means that HHH is not a decider is possible but not required.
>

>
*Perpetually ignoring this is not any actual rebuttal at all*
>
*Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination. The
only rebuttal to this is rejecting the notion that
deciders must always halt.

>
Wrong, because a termination analyzer is not required to halt.

>
Why say things that you know are untrue?

>
The term "termination analyzer" is used about programs that do not halt
on every input. There is no strict derfiniton of the term so there is
no requirement about halting.
>
On the first page of https://www.cs.princeton.edu/~zkincaid/pub/ pldi21.pdf
in the first parapgraph of Introduction:
>
    For example, termination analyzers may themselves fail to terminate on
    some input programs, or ...
>

A termination analyzer that doesn't halt
would flunk every proof of total program correctness.

>
There are no total termination analyzers.
>

>
Total proof of correctness does not require a halt
decider, it only requires a termination analyzer
with inputs in its domain.
>

>
WRONG.
>
To prove Turing wrong,

>
Is not what a proof of total correctness means.
>
Only requires proving that a software function derives
values corresponding to its input for its domain of
inputs AND  this software function halts for every
input.
>

>
First, you don't understand what "correctness" means, as it needs to derives a CORRECT value corresponding to its input, not just any old value.
>

 YES
 

And, to be able to show that it halts for every input,

 Termination Analyzers applied to a C function that
has no parameters is a simple exmaple of this.

But your C function isn't, by itself, a valid input, as both Halt Deciders and Termination Aalyzers have as their domain descriptions of PROGRAM (+ input for Halt Deciders) and programs include all the code they use, thus your function DDD needs to have the code of the HHH that it calls added to be part of it, and the input.

 

you need to first prove Turing wrong, as he shows that operation to be impossible in general.
>

 I first start with a termination analyzer on a
single input that has no inputs.

But not a valid input, as DDD isn't a program.
Either you need to include HHH as part of the input, or treat HHH as an implied input, at which point you broke your stipulation of no input.

 

Note, this doesn't say that proving a specific program is correct is impossible, because we can correctly show that many programs are halting, and even show them to always terminate. The limitation is that no analyzer will be correct for ALL inputs.
>

 This might not be the same domain as the domain for halt
deciders. Termination analyzers may be correct when they
conform to this:
 *Simulating termination analyzer Principle*
It is always correct for any simulating termination
analyzer to stop simulating and reject any input that
would otherwise prevent its own termination.

No, that is correct, when the input is a PROGRAM.
The problem is that when you make DDD into a program, the HHH that it calls is part of it, and that code is what causes it to reach its final state, so your "otherwise" clause never happens.

 

OF course, your claim that a correct program only needs to return some value corresponding to its input, and not a correct value, opens your crack for it to use a wrong correspondence, like your straw-man relationship.

 It seems to me that reasonable minds would agree with the above
*Simulating termination analyzer Principle*
 

But the problem is that your input doesn't correcspond to the requirements.
As a non-leaf function without some of the routines it calls, it doesn't HAVE behavior like halting.
So, your question is like "What Color is 3?"
IT is a nonsense question, that you make up false definitions to try to define an answer.
Sorry, your whole lifes work has been based on this sort of basic error where you just failed to learn the actual meaning of anything you talked about, but just fell into the trap of assuming you were smart enuough to figure it out, when it truth you were stupid enough to just deceive yourself into thinking you know.