Re: Proof that H(D,D) meets its abort criteria --Categorically Exhaustive Reasoning--

On 3/16/2024 6:54 PM, Richard Damon wrote:

On 3/16/24 11:57 AM, olcott wrote:

On 3/16/2024 12:33 PM, immibis wrote:

On 16/03/24 18:04, olcott wrote:

On 3/16/2024 11:53 AM, Richard Damon wrote:

On 3/16/24 8:23 AM, olcott wrote:

On 3/16/2024 12:22 AM, Richard Damon wrote:

On 3/15/24 10:00 PM, olcott wrote:

On 3/15/2024 11:52 PM, Richard Damon wrote:

On 3/15/24 8:41 PM, olcott wrote:

On 3/15/2024 10:11 PM, Richard Damon wrote:

On 3/15/24 8:00 PM, olcott wrote:

On 3/15/2024 9:47 PM, Richard Damon wrote:

On 3/15/24 7:18 PM, olcott wrote:

On 3/15/2024 8:22 PM, Richard Damon wrote:

On 3/15/24 5:49 PM, olcott wrote:

On 3/15/2024 6:37 PM, Mike Terry wrote:

On 15/03/2024 18:45, immibis wrote:

On 15/03/24 19:39, olcott wrote:

On 3/15/2024 1:38 PM, immibis wrote:

On 15/03/24 18:52, olcott wrote:

On 3/15/2024 12:36 PM, Richard Damon wrote:

On 3/15/24 9:20 AM, olcott wrote:

Best selling author of Theory of Computation textbooks:
*Introduction To The Theory Of Computation 3RD, by sipser*
https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>
Date 10/13/2022 11:29:23 AM
*MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
(He has neither reviewed nor agreed to anything else in this paper)
(a) 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
(b) H can abort its simulation of D and correctly report that D specifies a non-halting sequence of configurations.
>
*When we apply the abort criteria* (elaborated above)
Will you halt if you never abort your simulation?
*Then H(D,D) is proven to meet this criteria*
>
*Proof that H(D,D) meets its abort criteria*
>
int D(int (*x)())
{
   int Halt_Status = H(x, x);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
}
>
int main()
{
   Output("Input_Halts = ", H(D,D));
}
>
  machine   stack     stack     machine    assembly
  address   address   data      code       language
  ========  ========  ========  ========= =============
[00001d22][00102fc9][00000000] 55         push ebp ; begin main()
[00001d23][00102fc9][00000000] 8bec       mov ebp,esp
[00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
[00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
[00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>
H: Begin Simulation   Execution Trace Stored at:113075
Address_of_H:1522
[00001cf2][00113061][00113065] 55         push ebp ; enter D(D)
[00001cf3][00113061][00113065] 8bec       mov ebp,esp
[00001cf5][0011305d][00103031] 51         push ecx
[00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
[00001cf9][00113059][00001cf2] 50         push eax ; push D
[00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
[00001cfd][00113055][00001cf2] 51         push ecx ; push D
[00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
H: Recursive Simulation Detected Simulation Stopped
                           H(D,D) returns 0 to main()
>
*That was proof that H(D,D) meets its abort criteria*
H(D,D) correctly determines that itself is being called with its same inputs and there are no conditional branch instructions between the invocation of D(D) and its call to H(D,D).
>
>

>
Except that D calling H(D,D) does NOT prove the required (a), since the simulated D WILL stop running because *ITS* H will abort *ITS* simulation and returm 0 so that simulated D will halt.

You keep saying that H(D,D) never really needs to abort the
simulation of its input because after H(D,D) has aborted the
simulation of this input it no longer needs to be aborted.
>

You keep thinking there is more than one H(D,D) and then when it's convenient for you you think there is only one H(D,D). Why is that?

>
The first H(D,D) to see that the abort criteria has been met
(the outermost one) must abort the simulation of its input or
none of them ever abort.
>

>
that's wrong. They all abort, so if we prevent the first one from aborting, the second one will abort. If we prevent the first and second ones from aborting, the third one will abort.

>
Correct - but PO has the wrong understanding of "prevent".
>
Correct understanding:  We're discussing a (putative) HD H examining an input (P,I) representing some /fixed/ computation. When we talk about "preventing" H from doing xxxxx (such as aborting a simulation) we mean how an amended version H2 (like H but without xxxxx) behaves in examining that /same input/ (P,I).
>

>
*It can be construed that way, yet that is not it*
In software engineering the above is simply a pair of distinct
execution paths based on a conditional test within the same program.
In both cases D is simply a fixed constant string of machine-code bytes.

>
Right D is a FIXED constant string, and thus the meaning doesn't change if we hypothsize about changing an H.
>

It always calls whatever H is at the fixed machine address
that is encoded within D.

>
In other words, it has NOTHING to do with Turing Machines, and thus has NO application to the Linz proof, and you are admitting you are LYING about it having application.
>
As D isn't a "Computation" as it takes a "hidden input", namely thely the contents of them memory now called "H". (It isn't PART OF D, and isn't a declared parameter to D, so it is a "Hidden Input"
>

>
I told you that you will not have the basis (prerequisite knowledge)
to see how this is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩ until after you see how
H(D,D) does correctly determine that it must abort its simulation.
>

>
This means that it DOES call H(D,D) in recursive simulation and
DOES NOT call H1(D,D) in recursive simulation.
>

>
And means you have been LYING that it has ANYTHING to do with the HALTING PROBLEM
>

Thus H(D,D) must account for this difference and H1(D,D) can
ignore this difference.
>

>
When we use categorically exhaustive reasoning instead of locking
ourselves into the pathological thinking of Richard where H tries
to second guess itself such that anything that H(D,D) does can somehow
be construed as incorrect...

>
Sounds like buzzwords.
>
H doesn't try to second guess, H does what H does. PERIOD. That is all it can do.
>
You don't seem to understand how programs work.
>

>
We as humans analyze everything that every encoding of H can possibly
do and find that categorically every H that never aborts its simulation
results in D(D) never halting.

>
Right. But that doesn't mean that any of the H that DO abort is correct

>
It means that every H(D,D) that correctly determines by a partial
simulation of its input: "H correctly simulates its input D until"
that "D would never stop running unless aborted" that this H(D,D)
<is> necessarily correct.

>
But means you haven't said ANYTHING about Turing Machines or the actual Halting Problem.
>

>

saying non-halting as it now is looking at a TOTALLY new set of input.
>
You don't seem very "Exhaustive" in your reasoning.
>

>
// The categorically exhaustive part
For every H(D,D) of the infinite set of encodings of H
that simulate their input
>
*no D(D) ever stops running unless aborted by H*

>
But now, your question isn't the Halting Question, since D isn't actually a comptation anymore, as it has a hidden input.
>

>
I told you that you will not have the basis (prerequisite knowledge)
to see how this is isomorphic to H ⟨Ĥ⟩ ⟨Ĥ⟩ until after you see how
H(D,D) does correctly determine that it must abort its simulation.

>
So, you just admitted that your D CAN'T be isomophic to H^, so you ar just lying.
>
>
>

>

>
This is how we break out of the double-think of construing
that no H(D,D) can possibly correctly match the recursive
simulation non-halting behavior pattern.
>
https://en.wikipedia.org/wiki/Doublethink
*>

So you lie again.
>
What are the two contradictory ideas?
>

>
That no H(D,D) can possibly correctly determine that
it must abort its simulation because after it already
has aborted its simulation it doesn't need to do this.
>

>
So, one thing is two things?
>
I guess you are dumber that I thought.
>

Your H STILL gets the wrong answer, as D(D) still halts when H(D,D) says it doesn't.
>

>
*We have never been talking about this in this whole thread*
*We are only talking about H(D,D) meeting its abort criteria*

>
But saying your abort criteria is a HALTING criteria.
>

It make have been confusing because I quote all of what professor
Sipser said. I try to stick exactly within the scope of the title
of the post: [Proof that H(D,D) meets its abort criteria] thus I
was only referring to the (a) criteria of the full quote.
>

So, you lie.
>

>

Perhaps you can claim your "Need to abort" criteria is meet, but that still isn't the halting criteria.

>
When we mutually agree that H(D,D) does correctly determine
that it must abort its simulation of D(D) and show how and
why this is correct then we can move on to the next point.
>

>
But we have proved that the aborting criteria is not a Halting Criteria.
>

The abort criteria derives the exact same result as the
conventional halting criteria yet does not make the mistake
of expecting H to report on behavior that it does not see.
In these cases it derives a different result.
>

>
So, you are saying Halting == Not Halting, since the conventional Halting Criteria says that D(D) Halts, since H(D,D) says 0, and D is designed to halt if H(D,D) says 0.
>
And your abort criteria says it is non-halting.
>
So, BOOM, you logic system just exploded in contradiciton, or you admit you are a liar.

>
I admit that the original criteria is incorrect when the basis
is that H(D,D) always reports on the behavior that it actually sees.
>
On the different basis of dividing program/input pairs into those
that halt and those that do not, we need a third return value of ERROR.

>
But, Halting isn't a function of the decider, so the "program" part of the Program/Input pair we want are the Program encoded in the description with the input it is given.
>

>
The original halt status criteria has the impossible requirement
that H(D,D) must report on behavior that it does not actually see.
Requiring H to be clairvoyant is an unreasonable requirement.
*The criteria shown below eliminate the requirement of clairvoyance*

>
It is a NON-COMPUTABLE requriment.
>
That is not INVALID.
>

>
None-the-less it <is> what you keep insisting is required.

>
To make a halting decider, it is required to compute this requirement.
>
This requirement cannot be computed, so halting deciders cannot be made.

>
In the same {logical impossibility} sort of way that no CAD system can correctly draw a square circle
>
and no one can correctly answer this question:
Is this sentence true or false: "This sentence is not true" ?
>

 Nope. Just shows your stupidity.
 The CAD issue is a definitional impossible (a square is not a circle).
 The Liar's paradox is a statement without a solution.
 Halting is a well defined mapping,

It is a well defined mapping from inputs to halt behavior.
It is a *logically impossible* mapping from algorithm/input
pairs to accept or reject state.
*logically impossible* never places any actual limit on anyone
or anything even though it superficially seems to.

so asking if you can make a machine to compute that mapping is a reasonable question. The fact that it isn't possible is just a happenstance.
 

Likewise is seems to be a reasonable question to ask if a
simple sentence is true or false.
(a) 2 + 3 = 5.
(b) What time is it?
(c) This sentence is not true.
The pathological self reference of (c) is isomorphic to the
halting problem counter-example input.

The fact that you don't understand the difference shows your ignorance.

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