Theirs can do things that mine cannot and mine can do things that theirs
cannot. https://aprove.informatik.rwth-aachen.de/interface/submission

My system can handle this theirs cannot.

void Simulate(int (*x)(), int (*y)())
{ x(y);
}

int D(int (*x)())
{ Simulate(x, x);
}

int main()
{ D(D);
}

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/6/23 2:04 AM, olcott wrote:
> Theirs can do things that mine cannot and mine can do things that theirs
> cannot. https://aprove.informatik.rwth-aachen.de/interface/submission
>
> My system can handle this theirs cannot.
>
> void Simulate(int (*x)(), int (*y)())
> {
>   x(y);
> }

Which is mis-named, as it doesn't "Simulate" its input.

>
> int D(int (*x)())
> {
>   Simulate(x, x);
> }
>
> int main()
> {
>   D(D);
> }
>
>

But, as you should know, that isn't the "D" or "P" or "H^" of the
Halting problem, since that calls "H", the Halt Decider, and not just a
"Simulator"

Now, it seems you stupidly think that you decider and a pure simulator
can botn be the same thing and also be different, which shows that
failing of your logic system.

Your corrent posted "termination analyzer", and what it can detect is
probably on par with a first-year project. Perhaps a bigger code base,
since you chose a very inefficient method of doing things, but no more
performant. You code only finds the most simple of looping conditions,
and does not handle correctly programs that recurse through it, as it
assumes that calls to itself are calls to a pure simulator, not actually
calls to itself.

On 6/6/2023 1:04 AM, olcott wrote:
> Theirs can do things that mine cannot and mine can do things that theirs
> cannot. https://aprove.informatik.rwth-aachen.de/interface/submission
>
> My system can handle this theirs cannot.
>
> void Simulate(int (*x)(), int (*y)())
> {
>   x(y);
> }
>
> int D(int (*x)())
> {
>   Simulate(x, x);
> }
>
> int main()
> {
>   D(D);
> }
>
>

For the above code my termination analyzer is superior to the state of
the art most cited termination analyzer: AProVE2023

int Simulate(int (*x)(), int (*y)())
{ x(y);
return 1;
}

int D(int (*x)())
{ int Halt_Status = Simulate(x, x);
if (Halt_Status)
HERE: goto HERE;
return Halt_Status;
}

int main()
{ D(D);
}

This is the AProVE2023 "I don't know" answer:
Termination could not be shown (Maybe)

*This is the x86utm.H(D,D) answer*
Output("Input_Halts = ", H(D,D));
Input_Halts = 0

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/6/2023 10:06 AM, olcott wrote:
> On 6/6/2023 1:04 AM, olcott wrote:
>> Theirs can do things that mine cannot and mine can do things that
>> theirs cannot.
>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>
>> My system can handle this theirs cannot.
>>
>> void Simulate(int (*x)(), int (*y)())
>> {
>>    x(y);
>> }
>>
>> int D(int (*x)())
>> {
>>    Simulate(x, x);
>> }
>>
>> int main()
>> {
>>    D(D);
>> }
>>
>>
>
> For the above code my termination analyzer is superior to the state of
> the art most cited termination analyzer: AProVE2023
>
> int Simulate(int (*x)(), int (*y)())
> {
>   x(y);
>   return 1;
> }
>
> int D(int (*x)())
> {
>   int Halt_Status = Simulate(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   D(D);
> }
>
> This is the AProVE2023 "I don't know" answer:
> Termination could not be shown (Maybe)
>
> *This is the x86utm.H(D,D) answer*
> Output("Input_Halts = ", H(D,D));
> Input_Halts = 0
>

AProVE has had at least 20 years of developmental effort.
https://aprove.informatik.rwth-aachen.de/references

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/6/23 11:06 AM, olcott wrote:
> On 6/6/2023 1:04 AM, olcott wrote:
>> Theirs can do things that mine cannot and mine can do things that
>> theirs cannot.
>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>
>> My system can handle this theirs cannot.
>>
>> void Simulate(int (*x)(), int (*y)())
>> {
>>    x(y);
>> }
>>
>> int D(int (*x)())
>> {
>>    Simulate(x, x);
>> }
>>
>> int main()
>> {
>>    D(D);
>> }
>>
>>
>
> For the above code my termination analyzer is superior to the state of
> the art most cited termination analyzer: AProVE2023

But was considered solved 40 years ago, so obviously your idea of "State
of the Art" is flawed.

>
> int Simulate(int (*x)(), int (*y)())
> {
>   x(y);
>   return 1;
> }
>
> int D(int (*x)())
> {
>   int Halt_Status = Simulate(x, x);
>   if (Halt_Status)
>     HERE: goto HERE;
>   return Halt_Status;
> }
>
> int main()
> {
>   D(D);
> }
>
> This is the AProVE2023 "I don't know" answer:
> Termination could not be shown (Maybe)
>
> *This is the x86utm.H(D,D) answer*
> Output("Input_Halts = ", H(D,D));
> Input_Halts = 0
>
>
>

And, since that isn't the program from the Halting Problem proof,
meaningess.

Your problem is your Halt Decider gives the same answer for an input
that DOES halt, so is wrong.

Remember, when D(m) calls H(m,m) then D(D) is shown to halt because your
H(D,D) returns 0, so H should have returned 1, so was wrong.

As the problem you are quoting specifies, the correct answer is to the
ACTUAL programs behavior, not can the decider correctly simulate the
input to the final state.

On 6/6/2023 5:45 PM, Richard Damon wrote:
> On 6/6/23 11:06 AM, olcott wrote:
>> On 6/6/2023 1:04 AM, olcott wrote:
>>> Theirs can do things that mine cannot and mine can do things that
>>> theirs cannot.
>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>
>>> My system can handle this theirs cannot.
>>>
>>> void Simulate(int (*x)(), int (*y)())
>>> {
>>>    x(y);
>>> }
>>>
>>> int D(int (*x)())
>>> {
>>>    Simulate(x, x);
>>> }
>>>
>>> int main()
>>> {
>>>    D(D);
>>> }
>>>
>>>
>>
>> For the above code my termination analyzer is superior to the state of
>> the art most cited termination analyzer: AProVE2023
>
> But was considered solved 40 years ago, so obviously your idea of "State
> of the Art" is flawed.
>
>
>
>>
>> int Simulate(int (*x)(), int (*y)())
>> {
>>    x(y);
>>    return 1;
>> }
>>
>> int D(int (*x)())
>> {
>>    int Halt_Status = Simulate(x, x);
>>    if (Halt_Status)
>>      HERE: goto HERE;
>>    return Halt_Status;
>> }
>>
>> int main()
>> {
>>    D(D);
>> }
>>
>> This is the AProVE2023 "I don't know" answer:
>> Termination could not be shown (Maybe)
>>
>> *This is the x86utm.H(D,D) answer*
>> Output("Input_Halts = ", H(D,D));
>> Input_Halts = 0
>>
>>
>>
>
> And, since that isn't the program from the Halting Problem proof,
> meaningess.
>

It proves that my termination analyzer can do things that the most
sophisticated termination analyzer in the world cannot do.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Le 07/06/2023 à 01:20, olcott a écrit :
> On 6/6/2023 5:45 PM, Richard Damon wrote:
>> On 6/6/23 11:06 AM, olcott wrote:
>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>> Theirs can do things that mine cannot and mine can do things that
>>>> theirs cannot.
>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>
>>>> My system can handle this theirs cannot.
>>>>
>>>> void Simulate(int (*x)(), int (*y)())
>>>> {
>>>>    x(y);
>>>> }
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    Simulate(x, x);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    D(D);
>>>> }
>>>>
>>>>
>>>
>>> For the above code my termination analyzer is superior to the state
>>> of the art most cited termination analyzer: AProVE2023
>>
>> But was considered solved 40 years ago, so obviously your idea of
>> "State of the Art" is flawed.
>>
>>
>>
>>>
>>> int Simulate(int (*x)(), int (*y)())
>>> {
>>>    x(y);
>>>    return 1;
>>> }
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = Simulate(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    D(D);
>>> }
>>>
>>> This is the AProVE2023 "I don't know" answer:
>>> Termination could not be shown (Maybe)
>>>
>>> *This is the x86utm.H(D,D) answer*
>>> Output("Input_Halts = ", H(D,D));
>>> Input_Halts = 0
>>>
>>>
>>>
>>
>> And, since that isn't the program from the Halting Problem proof,
>> meaningess.
>>
>
> It proves that my termination analyzer can do things that the most
> sophisticated termination analyzer in the world cannot do.
>

Aheum. No.

On 6/6/23 7:20 PM, olcott wrote:
> On 6/6/2023 5:45 PM, Richard Damon wrote:
>> On 6/6/23 11:06 AM, olcott wrote:
>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>> Theirs can do things that mine cannot and mine can do things that
>>>> theirs cannot.
>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>
>>>> My system can handle this theirs cannot.
>>>>
>>>> void Simulate(int (*x)(), int (*y)())
>>>> {
>>>>    x(y);
>>>> }
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    Simulate(x, x);
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    D(D);
>>>> }
>>>>
>>>>
>>>
>>> For the above code my termination analyzer is superior to the state
>>> of the art most cited termination analyzer: AProVE2023
>>
>> But was considered solved 40 years ago, so obviously your idea of
>> "State of the Art" is flawed.
>>
>>
>>
>>>
>>> int Simulate(int (*x)(), int (*y)())
>>> {
>>>    x(y);
>>>    return 1;
>>> }
>>>
>>> int D(int (*x)())
>>> {
>>>    int Halt_Status = Simulate(x, x);
>>>    if (Halt_Status)
>>>      HERE: goto HERE;
>>>    return Halt_Status;
>>> }
>>>
>>> int main()
>>> {
>>>    D(D);
>>> }
>>>
>>> This is the AProVE2023 "I don't know" answer:
>>> Termination could not be shown (Maybe)
>>>
>>> *This is the x86utm.H(D,D) answer*
>>> Output("Input_Halts = ", H(D,D));
>>> Input_Halts = 0
>>>
>>>
>>>
>>
>> And, since that isn't the program from the Halting Problem proof,
>> meaningess.
>>
>
> It proves that my termination analyzer can do things that the most
> sophisticated termination analyzer in the world cannot do.
>

Nope, it proves you lie.

If the program you reference can't handle that EXACT program, then it
isn't the state of the art in termination analysis. (and if what you
gave it wasn't that exact program than your whole statement is a lie).

Note, if "Simulate" is a linker magic symbol that gets replaced with a
differentr function, then you are also lying, because the program being
analyized isn't the program shown.

Also note, YOUR program doesn't actually meet the requirements normally
given for termination alalysis, as that is the the analysis program is
given a COMPLETE program, but your analyizer can only be given a
"subprogram" that is contrained to be in the address space of the analyzer.

You also constrain the program to not be able to have a "copy" of the
analyizer, and maybe even not its own simulator, so you put a sharp line
of what you consider a "program".

These are FATAL flaws to you claims of working on the actual Halting
Problem.

On 6/6/2023 8:06 PM, Richard Damon wrote:
> On 6/6/23 7:20 PM, olcott wrote:
>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>> On 6/6/23 11:06 AM, olcott wrote:
>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>> Theirs can do things that mine cannot and mine can do things that
>>>>> theirs cannot.
>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>
>>>>> My system can handle this theirs cannot.
>>>>>
>>>>> void Simulate(int (*x)(), int (*y)())
>>>>> {
>>>>>    x(y);
>>>>> }
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    Simulate(x, x);
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    D(D);
>>>>> }
>>>>>
>>>>>
>>>>
>>>> For the above code my termination analyzer is superior to the state
>>>> of the art most cited termination analyzer: AProVE2023
>>>
>>> But was considered solved 40 years ago, so obviously your idea of
>>> "State of the Art" is flawed.
>>>
>>>
>>>
>>>>
>>>> int Simulate(int (*x)(), int (*y)())
>>>> {
>>>>    x(y);
>>>>    return 1;
>>>> }
>>>>
>>>> int D(int (*x)())
>>>> {
>>>>    int Halt_Status = Simulate(x, x);
>>>>    if (Halt_Status)
>>>>      HERE: goto HERE;
>>>>    return Halt_Status;
>>>> }
>>>>
>>>> int main()
>>>> {
>>>>    D(D);
>>>> }
>>>>
>>>> This is the AProVE2023 "I don't know" answer:
>>>> Termination could not be shown (Maybe)
>>>>
>>>> *This is the x86utm.H(D,D) answer*
>>>> Output("Input_Halts = ", H(D,D));
>>>> Input_Halts = 0
>>>>
>>>>
>>>>
>>>
>>> And, since that isn't the program from the Halting Problem proof,
>>> meaningess.
>>>
>>
>> It proves that my termination analyzer can do things that the most
>> sophisticated termination analyzer in the world cannot do.
>>
>
> Nope, it proves you lie.
>
> If the program you reference can't handle that EXACT program, then it
> isn't the state of the art in termination analysis.
That does not logically follow.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/6/23 10:03 PM, olcott wrote:
> On 6/6/2023 8:06 PM, Richard Damon wrote:
>> On 6/6/23 7:20 PM, olcott wrote:
>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>> Theirs can do things that mine cannot and mine can do things that
>>>>>> theirs cannot.
>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>
>>>>>> My system can handle this theirs cannot.
>>>>>>
>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>> {
>>>>>>    x(y);
>>>>>> }
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    Simulate(x, x);
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    D(D);
>>>>>> }
>>>>>>
>>>>>>
>>>>>
>>>>> For the above code my termination analyzer is superior to the state
>>>>> of the art most cited termination analyzer: AProVE2023
>>>>
>>>> But was considered solved 40 years ago, so obviously your idea of
>>>> "State of the Art" is flawed.
>>>>
>>>>
>>>>
>>>>>
>>>>> int Simulate(int (*x)(), int (*y)())
>>>>> {
>>>>>    x(y);
>>>>>    return 1;
>>>>> }
>>>>>
>>>>> int D(int (*x)())
>>>>> {
>>>>>    int Halt_Status = Simulate(x, x);
>>>>>    if (Halt_Status)
>>>>>      HERE: goto HERE;
>>>>>    return Halt_Status;
>>>>> }
>>>>>
>>>>> int main()
>>>>> {
>>>>>    D(D);
>>>>> }
>>>>>
>>>>> This is the AProVE2023 "I don't know" answer:
>>>>> Termination could not be shown (Maybe)
>>>>>
>>>>> *This is the x86utm.H(D,D) answer*
>>>>> Output("Input_Halts = ", H(D,D));
>>>>> Input_Halts = 0
>>>>>
>>>>>
>>>>>
>>>>
>>>> And, since that isn't the program from the Halting Problem proof,
>>>> meaningess.
>>>>
>>>
>>> It proves that my termination analyzer can do things that the most
>>> sophisticated termination analyzer in the world cannot do.
>>>
>>
>> Nope, it proves you lie.
>>
>> If the program you reference can't handle that EXACT program, then it
>> isn't the state of the art in termination analysis.
> That does not logically follow.
>

Since that exact program COULD be handled 40 years ago with well known
logic, a program that can't handle it now can't be "state of the art"

You don't seem to understand what the words mean.

Of course, my guess is that you don't actually mean what you say,
because you have shown yourself to be a pathological liar.

On 6/6/2023 9:48 PM, Richard Damon wrote:
> On 6/6/23 10:03 PM, olcott wrote:
>> On 6/6/2023 8:06 PM, Richard Damon wrote:
>>> On 6/6/23 7:20 PM, olcott wrote:
>>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>>> Theirs can do things that mine cannot and mine can do things that
>>>>>>> theirs cannot.
>>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>>
>>>>>>> My system can handle this theirs cannot.
>>>>>>>
>>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>>> {
>>>>>>>    x(y);
>>>>>>> }
>>>>>>>
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>    Simulate(x, x);
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    D(D);
>>>>>>> }
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> For the above code my termination analyzer is superior to the
>>>>>> state of the art most cited termination analyzer: AProVE2023
>>>>>
>>>>> But was considered solved 40 years ago, so obviously your idea of
>>>>> "State of the Art" is flawed.
>>>>>
>>>>>
>>>>>
>>>>>>
>>>>>> int Simulate(int (*x)(), int (*y)())
>>>>>> {
>>>>>>    x(y);
>>>>>>    return 1;
>>>>>> }
>>>>>>
>>>>>> int D(int (*x)())
>>>>>> {
>>>>>>    int Halt_Status = Simulate(x, x);
>>>>>>    if (Halt_Status)
>>>>>>      HERE: goto HERE;
>>>>>>    return Halt_Status;
>>>>>> }
>>>>>>
>>>>>> int main()
>>>>>> {
>>>>>>    D(D);
>>>>>> }
>>>>>>
>>>>>> This is the AProVE2023 "I don't know" answer:
>>>>>> Termination could not be shown (Maybe)
>>>>>>
>>>>>> *This is the x86utm.H(D,D) answer*
>>>>>> Output("Input_Halts = ", H(D,D));
>>>>>> Input_Halts = 0
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> And, since that isn't the program from the Halting Problem proof,
>>>>> meaningess.
>>>>>
>>>>
>>>> It proves that my termination analyzer can do things that the most
>>>> sophisticated termination analyzer in the world cannot do.
>>>>
>>>
>>> Nope, it proves you lie.
>>>
>>> If the program you reference can't handle that EXACT program, then it
>>> isn't the state of the art in termination analysis.
>> That does not logically follow.
>>
>
> Since that exact program COULD be handled 40 years ago with well known
> logic, a program that can't handle it now can't be "state of the art"
>

40 years ago termination analysis as an academic field of study did not
exist. In the last couple of decades most termination analysis has
coalesced around term rewrite systems. On the basis of the published
literature AProVE seems to lead the pack.

> You don't seem to understand what the words mean.
>
> Of course, my guess is that you don't actually mean what you say,
> because you have shown yourself to be a pathological liar.

And you define pathological liar as someone that makes honest mistakes.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/6/23 11:27 PM, olcott wrote:
> On 6/6/2023 9:48 PM, Richard Damon wrote:
>> On 6/6/23 10:03 PM, olcott wrote:
>>> On 6/6/2023 8:06 PM, Richard Damon wrote:
>>>> On 6/6/23 7:20 PM, olcott wrote:
>>>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>>>> Theirs can do things that mine cannot and mine can do things
>>>>>>>> that theirs cannot.
>>>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>>>
>>>>>>>> My system can handle this theirs cannot.
>>>>>>>>
>>>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>>>> {
>>>>>>>>    x(y);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int D(int (*x)())
>>>>>>>> {
>>>>>>>>    Simulate(x, x);
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    D(D);
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> For the above code my termination analyzer is superior to the
>>>>>>> state of the art most cited termination analyzer: AProVE2023
>>>>>>
>>>>>> But was considered solved 40 years ago, so obviously your idea of
>>>>>> "State of the Art" is flawed.
>>>>>>
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> int Simulate(int (*x)(), int (*y)())
>>>>>>> {
>>>>>>>    x(y);
>>>>>>>    return 1;
>>>>>>> }
>>>>>>>
>>>>>>> int D(int (*x)())
>>>>>>> {
>>>>>>>    int Halt_Status = Simulate(x, x);
>>>>>>>    if (Halt_Status)
>>>>>>>      HERE: goto HERE;
>>>>>>>    return Halt_Status;
>>>>>>> }
>>>>>>>
>>>>>>> int main()
>>>>>>> {
>>>>>>>    D(D);
>>>>>>> }
>>>>>>>
>>>>>>> This is the AProVE2023 "I don't know" answer:
>>>>>>> Termination could not be shown (Maybe)
>>>>>>>
>>>>>>> *This is the x86utm.H(D,D) answer*
>>>>>>> Output("Input_Halts = ", H(D,D));
>>>>>>> Input_Halts = 0
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And, since that isn't the program from the Halting Problem proof,
>>>>>> meaningess.
>>>>>>
>>>>>
>>>>> It proves that my termination analyzer can do things that the most
>>>>> sophisticated termination analyzer in the world cannot do.
>>>>>
>>>>
>>>> Nope, it proves you lie.
>>>>
>>>> If the program you reference can't handle that EXACT program, then
>>>> it isn't the state of the art in termination analysis.
>>> That does not logically follow.
>>>
>>
>> Since that exact program COULD be handled 40 years ago with well known
>> logic, a program that can't handle it now can't be "state of the art"
>>
>
> 40 years ago termination analysis as an academic field of study did not
> exist. In the last couple of decades most termination analysis has
> coalesced around term rewrite systems. On the basis of the published
> literature AProVE seems to lead the pack.

It might not have had the fancy name, but analysis of machines for
halting was an established field.

Again, you seem to be making bold claims based on lack of knowledge and
the assumption that you understand something you don't.

>
>> You don't seem to understand what the words mean.
>>
>> Of course, my guess is that you don't actually mean what you say,
>> because you have shown yourself to be a pathological liar.
>
> And you define pathological liar as someone that makes honest mistakes.
>

So, you admit you are making a mistake? I guess so.

Someone how starts by insisting that they MUST be right and much later
have to admit that they never knew what they were taling about IS a
pathological liar.

That describes you to the T.

So, yes, you ARE a pathological liar, because you have no understand of
what truth actually means.

The fact that you argue that a defintionally WRONG answer must be right
demonstrates that.

Sorry, you are just proving how ignorant you are.

On 6/6/2023 10:48 PM, Richard Damon wrote:
> On 6/6/23 11:27 PM, olcott wrote:
>> On 6/6/2023 9:48 PM, Richard Damon wrote:
>>> On 6/6/23 10:03 PM, olcott wrote:
>>>> On 6/6/2023 8:06 PM, Richard Damon wrote:
>>>>> On 6/6/23 7:20 PM, olcott wrote:
>>>>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>>>>> Theirs can do things that mine cannot and mine can do things
>>>>>>>>> that theirs cannot.
>>>>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>>>>
>>>>>>>>> My system can handle this theirs cannot.
>>>>>>>>>
>>>>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>>>>> {
>>>>>>>>>    x(y);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int D(int (*x)())
>>>>>>>>> {
>>>>>>>>>    Simulate(x, x);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    D(D);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> For the above code my termination analyzer is superior to the
>>>>>>>> state of the art most cited termination analyzer: AProVE2023
>>>>>>>
>>>>>>> But was considered solved 40 years ago, so obviously your idea of
>>>>>>> "State of the Art" is flawed.
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> int Simulate(int (*x)(), int (*y)())
>>>>>>>> {
>>>>>>>>    x(y);
>>>>>>>>    return 1;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int D(int (*x)())
>>>>>>>> {
>>>>>>>>    int Halt_Status = Simulate(x, x);
>>>>>>>>    if (Halt_Status)
>>>>>>>>      HERE: goto HERE;
>>>>>>>>    return Halt_Status;
>>>>>>>> }
>>>>>>>>
>>>>>>>> int main()
>>>>>>>> {
>>>>>>>>    D(D);
>>>>>>>> }
>>>>>>>>
>>>>>>>> This is the AProVE2023 "I don't know" answer:
>>>>>>>> Termination could not be shown (Maybe)
>>>>>>>>
>>>>>>>> *This is the x86utm.H(D,D) answer*
>>>>>>>> Output("Input_Halts = ", H(D,D));
>>>>>>>> Input_Halts = 0
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And, since that isn't the program from the Halting Problem proof,
>>>>>>> meaningess.
>>>>>>>
>>>>>>
>>>>>> It proves that my termination analyzer can do things that the most
>>>>>> sophisticated termination analyzer in the world cannot do.
>>>>>>
>>>>>
>>>>> Nope, it proves you lie.
>>>>>
>>>>> If the program you reference can't handle that EXACT program, then
>>>>> it isn't the state of the art in termination analysis.
>>>> That does not logically follow.
>>>>
>>>
>>> Since that exact program COULD be handled 40 years ago with well
>>> known logic, a program that can't handle it now can't be "state of
>>> the art"
>>>
>>
>> 40 years ago termination analysis as an academic field of study did not
>> exist. In the last couple of decades most termination analysis has
>> coalesced around term rewrite systems. On the basis of the published
>> literature AProVE seems to lead the pack.
>
>
> It might not have had the fancy name, but analysis of machines for
> halting was an established field.
>
> Again, you seem to be making bold claims based on lack of knowledge and
> the assumption that you understand something you don't.
My preliminary review indicates that my statements are reasonably
plausible. You are only a naysayer no matter what I say otherwise I
would challenge you to find a counter-example.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/7/23 12:10 AM, olcott wrote:
> On 6/6/2023 10:48 PM, Richard Damon wrote:
>> On 6/6/23 11:27 PM, olcott wrote:
>>> On 6/6/2023 9:48 PM, Richard Damon wrote:
>>>> On 6/6/23 10:03 PM, olcott wrote:
>>>>> On 6/6/2023 8:06 PM, Richard Damon wrote:
>>>>>> On 6/6/23 7:20 PM, olcott wrote:
>>>>>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>>>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>>>>>> Theirs can do things that mine cannot and mine can do things
>>>>>>>>>> that theirs cannot.
>>>>>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>>>>>
>>>>>>>>>> My system can handle this theirs cannot.
>>>>>>>>>>
>>>>>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>>>>>> {
>>>>>>>>>>    x(y);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int D(int (*x)())
>>>>>>>>>> {
>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    D(D);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> For the above code my termination analyzer is superior to the
>>>>>>>>> state of the art most cited termination analyzer: AProVE2023
>>>>>>>>
>>>>>>>> But was considered solved 40 years ago, so obviously your idea
>>>>>>>> of "State of the Art" is flawed.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> int Simulate(int (*x)(), int (*y)())
>>>>>>>>> {
>>>>>>>>>    x(y);
>>>>>>>>>    return 1;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int D(int (*x)())
>>>>>>>>> {
>>>>>>>>>    int Halt_Status = Simulate(x, x);
>>>>>>>>>    if (Halt_Status)
>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>    return Halt_Status;
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> int main()
>>>>>>>>> {
>>>>>>>>>    D(D);
>>>>>>>>> }
>>>>>>>>>
>>>>>>>>> This is the AProVE2023 "I don't know" answer:
>>>>>>>>> Termination could not be shown (Maybe)
>>>>>>>>>
>>>>>>>>> *This is the x86utm.H(D,D) answer*
>>>>>>>>> Output("Input_Halts = ", H(D,D));
>>>>>>>>> Input_Halts = 0
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And, since that isn't the program from the Halting Problem
>>>>>>>> proof, meaningess.
>>>>>>>>
>>>>>>>
>>>>>>> It proves that my termination analyzer can do things that the most
>>>>>>> sophisticated termination analyzer in the world cannot do.
>>>>>>>
>>>>>>
>>>>>> Nope, it proves you lie.
>>>>>>
>>>>>> If the program you reference can't handle that EXACT program, then
>>>>>> it isn't the state of the art in termination analysis.
>>>>> That does not logically follow.
>>>>>
>>>>
>>>> Since that exact program COULD be handled 40 years ago with well
>>>> known logic, a program that can't handle it now can't be "state of
>>>> the art"
>>>>
>>>
>>> 40 years ago termination analysis as an academic field of study did not
>>> exist. In the last couple of decades most termination analysis has
>>> coalesced around term rewrite systems. On the basis of the published
>>> literature AProVE seems to lead the pack.
>>
>>
>> It might not have had the fancy name, but analysis of machines for
>> halting was an established field.
>>
>> Again, you seem to be making bold claims based on lack of knowledge
>> and the assumption that you understand something you don't.
> My preliminary review indicates that my statements are reasonably
> plausible. You are only a naysayer no matter what I say otherwise I
> would challenge you to find a counter-example.
>

How do you justify calling a program that halts non-halting?

You even admit that the program halts, but say the correct answer can be
non-halting.

If you think that is a "reasonable" position, you are just stupid.

You also don't seem to understand the nature of how proofs work,
something isn't "proven" just because you haven't (yet) found a counter
example. The mere fact that you mention that sort of argument shows your
ignorance of the field.

On 6/7/2023 6:21 AM, Richard Damon wrote:
> On 6/7/23 12:10 AM, olcott wrote:
>> On 6/6/2023 10:48 PM, Richard Damon wrote:
>>> On 6/6/23 11:27 PM, olcott wrote:
>>>> On 6/6/2023 9:48 PM, Richard Damon wrote:
>>>>> On 6/6/23 10:03 PM, olcott wrote:
>>>>>> On 6/6/2023 8:06 PM, Richard Damon wrote:
>>>>>>> On 6/6/23 7:20 PM, olcott wrote:
>>>>>>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>>>>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>>>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>>>>>>> Theirs can do things that mine cannot and mine can do things
>>>>>>>>>>> that theirs cannot.
>>>>>>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>>>>>>
>>>>>>>>>>> My system can handle this theirs cannot.
>>>>>>>>>>>
>>>>>>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>>>>>>> {
>>>>>>>>>>>    x(y);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>    D(D);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> For the above code my termination analyzer is superior to the
>>>>>>>>>> state of the art most cited termination analyzer: AProVE2023
>>>>>>>>>
>>>>>>>>> But was considered solved 40 years ago, so obviously your idea
>>>>>>>>> of "State of the Art" is flawed.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> int Simulate(int (*x)(), int (*y)())
>>>>>>>>>> {
>>>>>>>>>>    x(y);
>>>>>>>>>>    return 1;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int D(int (*x)())
>>>>>>>>>> {
>>>>>>>>>>    int Halt_Status = Simulate(x, x);
>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>    return Halt_Status;
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> int main()
>>>>>>>>>> {
>>>>>>>>>>    D(D);
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> This is the AProVE2023 "I don't know" answer:
>>>>>>>>>> Termination could not be shown (Maybe)
>>>>>>>>>>
>>>>>>>>>> *This is the x86utm.H(D,D) answer*
>>>>>>>>>> Output("Input_Halts = ", H(D,D));
>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And, since that isn't the program from the Halting Problem
>>>>>>>>> proof, meaningess.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It proves that my termination analyzer can do things that the most
>>>>>>>> sophisticated termination analyzer in the world cannot do.
>>>>>>>>
>>>>>>>
>>>>>>> Nope, it proves you lie.
>>>>>>>
>>>>>>> If the program you reference can't handle that EXACT program,
>>>>>>> then it isn't the state of the art in termination analysis.
>>>>>> That does not logically follow.
>>>>>>
>>>>>
>>>>> Since that exact program COULD be handled 40 years ago with well
>>>>> known logic, a program that can't handle it now can't be "state of
>>>>> the art"
>>>>>
>>>>
>>>> 40 years ago termination analysis as an academic field of study did not
>>>> exist. In the last couple of decades most termination analysis has
>>>> coalesced around term rewrite systems. On the basis of the published
>>>> literature AProVE seems to lead the pack.
>>>
>>>
>>> It might not have had the fancy name, but analysis of machines for
>>> halting was an established field.
>>>
>>> Again, you seem to be making bold claims based on lack of knowledge
>>> and the assumption that you understand something you don't.
>> My preliminary review indicates that my statements are reasonably
>> plausible. You are only a naysayer no matter what I say otherwise I
>> would challenge you to find a counter-example.
>>
>
> How do you justify calling a program that halts non-halting?
>

The above program does not halt. You can't just cut-and-paste
pieces of prior conversations and plug them into the current
unrelated conversation.

--
Copyright 2023 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 6/7/23 10:52 AM, olcott wrote:
> On 6/7/2023 6:21 AM, Richard Damon wrote:
>> On 6/7/23 12:10 AM, olcott wrote:
>>> On 6/6/2023 10:48 PM, Richard Damon wrote:
>>>> On 6/6/23 11:27 PM, olcott wrote:
>>>>> On 6/6/2023 9:48 PM, Richard Damon wrote:
>>>>>> On 6/6/23 10:03 PM, olcott wrote:
>>>>>>> On 6/6/2023 8:06 PM, Richard Damon wrote:
>>>>>>>> On 6/6/23 7:20 PM, olcott wrote:
>>>>>>>>> On 6/6/2023 5:45 PM, Richard Damon wrote:
>>>>>>>>>> On 6/6/23 11:06 AM, olcott wrote:
>>>>>>>>>>> On 6/6/2023 1:04 AM, olcott wrote:
>>>>>>>>>>>> Theirs can do things that mine cannot and mine can do things
>>>>>>>>>>>> that theirs cannot.
>>>>>>>>>>>> https://aprove.informatik.rwth-aachen.de/interface/submission
>>>>>>>>>>>>
>>>>>>>>>>>> My system can handle this theirs cannot.
>>>>>>>>>>>>
>>>>>>>>>>>> void Simulate(int (*x)(), int (*y)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    x(y);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    Simulate(x, x);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    D(D);
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> For the above code my termination analyzer is superior to the
>>>>>>>>>>> state of the art most cited termination analyzer: AProVE2023
>>>>>>>>>>
>>>>>>>>>> But was considered solved 40 years ago, so obviously your idea
>>>>>>>>>> of "State of the Art" is flawed.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> int Simulate(int (*x)(), int (*y)())
>>>>>>>>>>> {
>>>>>>>>>>>    x(y);
>>>>>>>>>>>    return 1;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>> {
>>>>>>>>>>>    int Halt_Status = Simulate(x, x);
>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> int main()
>>>>>>>>>>> {
>>>>>>>>>>>    D(D);
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> This is the AProVE2023 "I don't know" answer:
>>>>>>>>>>> Termination could not be shown (Maybe)
>>>>>>>>>>>
>>>>>>>>>>> *This is the x86utm.H(D,D) answer*
>>>>>>>>>>> Output("Input_Halts = ", H(D,D));
>>>>>>>>>>> Input_Halts = 0
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And, since that isn't the program from the Halting Problem
>>>>>>>>>> proof, meaningess.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It proves that my termination analyzer can do things that the most
>>>>>>>>> sophisticated termination analyzer in the world cannot do.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Nope, it proves you lie.
>>>>>>>>
>>>>>>>> If the program you reference can't handle that EXACT program,
>>>>>>>> then it isn't the state of the art in termination analysis.
>>>>>>> That does not logically follow.
>>>>>>>
>>>>>>
>>>>>> Since that exact program COULD be handled 40 years ago with well
>>>>>> known logic, a program that can't handle it now can't be "state of
>>>>>> the art"
>>>>>>
>>>>>
>>>>> 40 years ago termination analysis as an academic field of study did
>>>>> not
>>>>> exist. In the last couple of decades most termination analysis has
>>>>> coalesced around term rewrite systems. On the basis of the published
>>>>> literature AProVE seems to lead the pack.
>>>>
>>>>
>>>> It might not have had the fancy name, but analysis of machines for
>>>> halting was an established field.
>>>>
>>>> Again, you seem to be making bold claims based on lack of knowledge
>>>> and the assumption that you understand something you don't.
>>> My preliminary review indicates that my statements are reasonably
>>> plausible. You are only a naysayer no matter what I say otherwise I
>>> would challenge you to find a counter-example.
>>>
>>
>> How do you justify calling a program that halts non-halting?
>>
>
> The above program does not halt. You can't just cut-and-paste
> pieces of prior conversations and plug them into the current
> unrelated conversation.
>

No, but the D/P/H^ that that calls H does, and your H says it is also
non-halting.

You try to LIE by reusing names for different programs.

You seem to forget your claims.

You are just proving your stupidity.