Re: V5 --- Professor Sipser

On 8/23/24 12:47 AM, olcott wrote:

On 8/22/2024 11:12 PM, Richard Damon wrote:

On 8/22/24 11:53 PM, olcott wrote:

On 8/22/2024 10:11 PM, Richard Damon wrote:

On 8/22/24 10:54 PM, olcott wrote:

On 8/22/2024 9:31 PM, Richard Damon wrote:

On 8/22/24 9:39 PM, olcott wrote:

On 8/22/2024 8:26 PM, Richard Damon wrote:

On 8/22/24 9:21 PM, olcott wrote:

On 8/22/2024 7:54 PM, Richard Damon wrote:

On 8/22/24 9:36 AM, olcott wrote:

On 8/22/2024 8:21 AM, joes wrote:

Am Thu, 22 Aug 2024 07:59:59 -0500 schrieb olcott:

On 8/22/2024 3:16 AM, Fred. Zwarts wrote:

Op 22.aug.2024 om 06:22 schreef olcott:

>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
      If simulating halt decider H correctly simulates its input D until
      H correctly determines that its simulated D would never stop
      running unless aborted then
      H can abort its simulation of D and correctly report that D
      specifies a non-halting sequence of configurations.
</MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>
We swap the word "determines" for "predicts"
When we swap thew word "halt decider" for "termination analyzer" the
above is translated from computer science into software engineering.
The second half proves that this is the H that aborts that is making the
prediction of the behavior of D when emulated by a hypothetical version
of itself then never aborts.

>

THIS EXACTLY MATCHES THE SIPSER APPROVED CRITERIA The finite HHH(DDD)
emulates itself emulating DDD exactly once and this is sufficient for
this HHH to predict what a different HHH(DDD) do that never aborted
its emulation of its input.

But that different hypothetical HHH is a non-input.

HHH is supposed to predict what the behavior of DDD would be if it did
not abort its emulation of DDD that is what the words that Professor
agreed to mean.

If IT didn’t abort DDD calling its aborting self.
>

>
I don't know how you twist words to get that.
HHH is required to predict the behavior of DDD
as if every HHH had its abort code removed.

>
But that isn't the input, so that is just a LIE.

>
PREDICT HYPOTHETICAL BEHAVIOR

Nope, Predict the ACTUAL behavior.
>
You are just admitting you are lying about the

>
That is NOT what the words actually say.
I hope you don't get condemned to Hell over this.
>

>
Yes, it is, at least when you understand the TECHNICAL meaning of the words in Computation Theory.

>
Termination analyzers in software engineering are
isomorphic to partial halt deciders in computer
science you really can't get away with saying otherwise
and not look foolish.

>
Then they must follow the same rules (or you are lying that they are isomoprhic).
>
Deciders of program behavior must be given PROGRAMS, which always contain ALL of the code used by it, thus for DDD, it includes the HHH that it calls.
>

>
It was ridiculous that you ever assumed otherwise.

>
But you keep on trying to pass of your "DDD" that doesn't contain HHH as your input.
>

 https://github.com/plolcott/x86utm/blob/master/Halt7.c
That code has been available for years, ask Mike to explain
it to you.

Yes, I have looked at it.
The *PROGRAM* DDD includes HHH, because it calls it, an a program includes all the code it uses.
You just seem totally ignorant of the meaning of the things you talk about.
Halt Deciders decide on the behavior of PROGRAMS, not "fragments" like just the function DDD without HHH would be.
Your ignoring that fact, just shows that you are just stupid.
Also, that code proves you are a LIAR about your deciders being pure functions of their input, as in the core of the functions they examine data not generated by them, or given as an explicit input, to set an internal flag that is used to change the behavior of the code.
Thus, your whole proof is shown to be a LIE.

 

>

Incomplete descriptions that just don't contain everything are just incorrect.
>
Also, "Termination analyzers" are NOT the same thing as a Halt Deciders, as the term "Termination Analyzers" refer to something that decides if a given program will Halt on ALL POSSIBLE inputs, rather than the specific given input that a Halt Decider decides on.
>

>
So you don't know what "isomorphic" means.
It does not mean identical in every respect.
Maybe "functionally equivalent" is easy for you.

>
It means of the same form "iso" same, "morph" form.
>
So, how do you consider them functionally equivalent if they don't do the same sort of thing.
>
Note, Termination analyzing is a MUCH tougher problem, and it CAN'T be done by simple emulation, but must be done in a much more abstract look at the operation.
>

 Not for inputs that have no inputs.

True, but that is just a special case, and there is nothing in the theories that make Termination analyzing be just like PARTIAL Halt Deciding. Both problem, in the full are about making a decider for ALL programs. It is just that in Software Engineering, it is taken as a given that the universal decider is not possible, so the partial is just presumed. In the same way, "Halt Deciding" in Software Engineering presumes we are only looking for partial deciders, and is asking how good can we make it, and what classes of program can be decided on.

 

>

Sorry, you are just proving your ignorance of what you are trying to talk about.
>

>
It is not I that am proving ignorance.
You didn't know what "isomorphic means"

>
No, *YOU* DON'T seem to, as there seems to be more differences in your comparison than similarities.
>
For example, NOTHING in the definiton of a "Termination Analzer" says it is "Partial".

 Saying partial only means that it is not all knowing.

No, it means it is not always answering or not always correct.
Programs don't "know", they "decide".

 

It is just that the field understand that they must be partial as it is impossible to do it completely.

  See that you are not as dumb as your words make you seem.

But it seems you are more so.

 

Jst as most discussion of trying to Halt Decide will assume partial results, unless specifically talking about the Halting Problem where the precision is needed.
>

 HHH is a termination analyzer for DDD and a full
halt decider with for the domain of consisting of
the finite string of the x86 machine code of DDD.
 

Then it doesn't refute the Halting Problem, and that you are just a liar in your claim that it does.
A Termination Analyzer takes as its input the FULL CODE of the program.
The short finite string you say it is taking as its input is not a program, as it doesn't contain all the code of the program, so the thing it represents is not a program, and yo logic is shown to be just a LIE>

>

>

Something you are just IGNORANT of.
>
Sorry, you are just proving your utter stupidty by your instance of talking about something you haven't actually studied by just think you know.

>
>

>
>
>

>
>