Re: Simulating termination analyzers by dummies --- criteria is met

On 6/24/24 9:46 AM, olcott wrote:

On 6/24/2024 2:22 AM, Mikko wrote:

On 2024-06-23 13:13:42 +0000, olcott said:
>

On 6/23/2024 2:57 AM, Mikko wrote:

On 2024-06-22 14:11:28 +0000, olcott said:
>

On 6/22/2024 8:27 AM, Richard Damon wrote:

On 6/22/24 9:04 AM, olcott wrote:

>

>
I am the sole inventor of the simulating halt decider.
>
Ben Bacarisse contacted professor Sipser to verify that he
really did says this. The details are in this forum about
the same date.
>
https://www.amazon.com/Introduction-Theory-Computation-Michael-Sipser/dp/113318779X/
>
<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>

>
And, as I remember, he also verified that he disagrees with your definition of correct simulation.
>

>
*Ben also verified that the criteria have been met*
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. 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.

>
Right, Ben was willing to do what I am not that you can prove that, by your definition, H can show that it "must" abort its simulation or the input will run forever.
>
But, just like me, he also agrees that this is NOT the defintion of Halting, so H is just shown to be a correct (partial) POOP decider but ot a Halt Decider, not even for that one input.
>

>
On 10/14/2022 7:44 PM, Ben Bacarisse wrote:
 > I don't think that is the shell game. 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.
 >
 > He knows and accepts that P(P) actually does stop. The
 > wrong answer is justified by what would happen if H
 > (and hence a different P) where not what they actually are.
 >
*Ben agrees that the criteria is met for the input*
>
Computable functions are the formalized analogue of the
intuitive notion of algorithms, in the sense that a function
is computable if there exists an algorithm that can do the
job of the function, i.e. *given an input of the function*
*domain it can return the corresponding output*
https://en.wikipedia.org/wiki/Computable_function
>
*Ben disagrees that the criteria is met for the non-input*
Yet no one here can stay focused on the fact that non-inputs
*DO NOT COUNT*

>
In particular, you can't. You have insisted that your "decider"
or "anlyzer" (or whatever word you happen to use) H or HH (or
hwatever name you happen to use) must return false because a
non-input (where instead of the actually called function another
function that does not halt is called) does not halt.
>

>
You said it backwards. When I say that I am not guilty and did
not rob the liquor store you cannot paraphrase this as he admitted
that he robbed the liquor store.

>
The important qestion is not whether you admit but what the police
finds out.
>

H performs a sequence of finite string transformations on
its finite input of x86 machine code. These transformations
include that D calls H(D,D) while being simulated by H. In
such a case the call from D to H(D,D) cannot possibly return.

>
Which is all we need to know about H in ordet to determine that
it is not a decider.
>

 void DDD()
{
   H0(DDD);
}
 _DDD()
[00002172] 55               push ebp      ; housekeeping
[00002173] 8bec             mov ebp,esp   ; housekeeping
[00002175] 6872210000       push 00002172 ; push DDD
[0000217a] e853f4ffff       call 000015d2 ; call H0(DDD)
[0000217f] 83c404           add esp,+04
[00002182] 5d               pop ebp
[00002183] c3               ret
Size in bytes:(0018) [00002183]
 The call from DDD to H0(DDD) when DDD is correctly emulated
by H0 cannot possibly return.
 

So?
Can you PROVE it?
And why do we care, since it isn't what Halting is defined to be.
DDD does halt if H0 gives an answer.