On 16/03/24 19:19, olcott wrote:
> On 3/16/2024 12:30 PM, immibis wrote:
>> On 16/03/24 16:28, olcott wrote:
>>> 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 purpose of a halting decider is to be clairvoyant. A halting
>> decider must decide that a program will never halt even if we run it
>> forever, without actually running it forever.
>>
> Not at all. Something like mathematical induction accurately
> extrapolates what the future behavior would be:

In other words: mathematical induction is clairvoyant.

On 16/03/24 19:57, 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:
>>>> 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

That's correct. 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" ?

This sentence cannot be written in mathematical logic. It is well-known
that English contains ambiguous sentences.

On 3/16/2024 2:56 PM, immibis wrote:
> On 16/03/24 19:19, olcott wrote:
>> On 3/16/2024 12:30 PM, immibis wrote:
>>> On 16/03/24 16:28, olcott wrote:
>>>> 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 purpose of a halting decider is to be clairvoyant. A halting
>>> decider must decide that a program will never halt even if we run it
>>> forever, without actually running it forever.
>>>
>> Not at all. Something like mathematical induction accurately
>> extrapolates what the future behavior would be:
>
> In other words: mathematical induction is clairvoyant.

Not at all. Mathematical induction extrapolates on the basis of
what it sees. Requiring H(D,D) to report on behavior that it cannot
even see is incorrect.

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

On 16/03/24 20:03, olcott wrote:
> On 3/16/2024 12:32 PM, immibis wrote:
>> On 16/03/24 17:56, olcott wrote:
>>> *The timing is different*
>>
>> Turing machines don't have timing
>
> Sure they do.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different result than Ĥ ⟨Ĥ⟩
> because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is executed :
> BEFORE it has aborted its simulation and Ĥ ⟨Ĥ⟩ is executed
> AFTER Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has aborted its simulation.
>

No, the same Turing machine with the same initial tape contents will
always produce the same final tape contents and halting state (or not
halt) no matter when you run it.

On 16/03/24 20:19, olcott wrote:
> On 3/16/2024 12:31 PM, immibis wrote:
>> On 16/03/24 15:51, olcott wrote:
>>> I keep posting the same point until it gets a complete and correct
>>> review. This has proved to be very effective in that I am finally
>>> getting complete closure on some of these points.
>>>
>>> There cannot possibly exist any H(D,D) that is called by
>>> D where H(D,D) simulates its input and D(D) stops running
>>> and H never aborts its simulation.
>>>
>>
>> These words don't mean anything.
>
> Since all words always mean something why lie?
>
colorless green ideas sleep furiously

On 3/16/24 9:22 AM, olcott wrote:
> On 3/16/2024 10:45 AM, Richard Damon wrote:
>> On 3/16/24 8:09 AM, olcott wrote:
>>> On 3/16/2024 3:29 AM, Mikko wrote:
>>>> On 2024-03-15 20:25:50 +0000, olcott said:
>>>>
>>>>> On 3/15/2024 3:06 PM, Richard Damon wrote:
>>>>>> On 3/15/24 12:53 PM, olcott wrote:
>>>>>>> On 3/15/2024 2:49 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 12:25 PM, olcott wrote:
>>>>>>>>> On 3/15/2024 2:19 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/24 12:06 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 1:31 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2024 1:15 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/15/24 10:23 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2024 12:07 PM, immibis wrote:
>>>>>>>>>>>>>>> On 15/03/24 17:20, 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).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> There are conditional branch instructions inside H(D,D).
>>>>>>>>>>>>>>> This is obvious. Why do you keep lying?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (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
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> It is true that D(D) would never stop running unless the
>>>>>>>>>>>>>> outermost H(D,D) aborts its simulation thus meeting the
>>>>>>>>>>>>>> above criteria.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope, not if D is claimed to be the equivalent of Linz H^.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you are willing to DISAVOW any posssible conntection to
>>>>>>>>>>>>> that we can discuss that version, but then you are
>>>>>>>>>>>>> admitting this is just a time wasting change of topic.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The issue becomes a definition of identity.
>>>>>>>>>>>>>
>>>>>>>>>>>>> IF we are in an equivalency to Linz H/H^, then the H that D
>>>>>>>>>>>>> calls is a seperate identity to the H that is simulating
>>>>>>>>>>>>> that D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Thus, the outer H doesn't NEED to abort,
>>>>>>>>>>>>
>>>>>>>>>>>> (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
>>>>>>>>>>>>
>>>>>>>>>>>> That is incorrect yet too difficult for you to understand
>>>>>>>>>>>> that it is incorrect until after you first understand that
>>>>>>>>>>>> D(D,D)==0 is correct for the above criteria.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Typo I meant H(D,D).
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> WHich I assumed as a possibility and refuted.
>>>>>>>>>>
>>>>>>>>>> H(D,D) == 0 can't be the correct answer for a Halting Decider
>>>>>>>>>> as D(D) Halts, so the correct answer would be 1.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *That is the strawman deception to the title of this thread*
>>>>>>>>
>>>>>>>> But your title is refering to your own strawman.
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>>> Not at all. This thread is all about whether or not H(D,D) meets
>>>>>>> its abort criteria.
>>>>>>>
>>>>>>
>>>>>> Which, because you ask Profeser Sipser, about Turing Machine
>>>>>> equivalents,
>>>>>
>>>>> It was always about x86 emulators simulating C functions.
>>>>
>>>> No, what Professor Sipser agreed with does not mention C, functions,
>>>> nor x86. He clearly said he agrees with only that and no more.
>>>>
>>>
>>> *This is the same version 10/10/22 11:36:14 AM*
>>> *that professor Sipser was presented with*
>>>
>>> Rebutting the Sipser Halting Problem Proof
>>> https://philarchive.org/archive/OLCRTSv1
>>>
>>
>> Rigth, so not at all with what you claim he was talking about.
>>
>> As fully explained elsewhere and you ignored.
>>
>> You are thus just proven to be a stupid liar.
>
> From the first page of the original paper that I sent to Professor Sipser
>
> <Quoted Paper>
> We encode the Sipser D and define the behavior of Sipser H as C functions.
> //
> // H returns 1 when its input would halt and return 1.
> // otherwise H returns 0
> //
> int Sipser_D(ptr2 M)
> {
>  if ( Sipser_H(M, M) )
>    return 0;
>  return 1;
> }
>
> int main()
> {
>  Output((char*)"Input_Halts = ", Sipser_D(Sipser_D));
> }
>
> Complete halt deciding system (Visual Studio Project) Sipser version.
> (a) x86utm operating system
> (b) x86 emulator adapted from libx86emu to compile under Windows
> (c) Several halt deciders and their sample inputs contained within Halt7.c
>  https://liarparadox.org/2022_10_08.zip
>
> D calls simulating halt decider H which computes the mapping from its
> input D to an accept or reject state on the basis of its correct
> simulation of D. When H correctly determines that this simulated input
> would remain stuck in recursive simulation H aborts this simulation and
> reports non-halting by returning 0. When D reverses this decision it
> returns 1. This is used to correctly fill in the “?” in the Sipser
> Figure 4.6 with “accept”.
> </Quoted Paper>
>
> Sipser_D merely contradicts Sipser_H in a different way.
> Sipser_H(Sipser_D, Sipser_D) still rejects its input on
> the basis of recursive simulation.
>
> Sipser_H, H and H1 all use this function:
> u32 Decide_Halting()
>

On 3/16/2024 2:57 PM, immibis wrote:
> On 16/03/24 19:57, 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:
>>>>> 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
>
> That's correct. 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" ?
>
> This sentence cannot be written in mathematical logic. It is well-known
> that English contains ambiguous sentences.
>

https://www.researchgate.net/publication/331859461_Minimal_Type_Theory_YACC_BNF

LP := ~True(LP) is correctly formalized in MTT.

?- LP = not(true(LP)).
LP = not(true(LP)).

?- unify_with_occurs_check(LP, not(true(LP))).
false.

Prolog correctly determines that the structure of the above Prolog
expression: "ends up standing for some kind of infinite structure"

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

On 3/16/24 9:36 AM, olcott wrote:
> On 3/16/2024 10:51 AM, Richard Damon wrote:
>> On 3/16/24 7:51 AM, olcott wrote:
>>> On 3/16/2024 3:41 AM, Mikko wrote:
>>>> On 2024-03-15 18:45:34 +0000, immibis said:
>>>>
>>>>> On 15/03/24 19:35, olcott wrote:
>>>>>> On 3/15/2024 1:24 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 10:52 AM, 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 confuse the identities.
>>>>>>>
>>>>>>> *THIS* (the outer instance) doesn't need to abort its simulation,
>>>>>>> because since the *OTHER* (the simulated version) does, and thus
>>>>>>> the correct simulation of the input provided does halt.
>>>>>>>
>>>>>>
>>>>>> 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.
>>>>>>
>>>>> Posting the exact same message 5 times doesn't make it correct.
>>>>
>>>> But it makes the author look stupid, which may be the
>>>> right thing to do.
>>>>
>>>
>>> I keep posting the same point until it gets a complete and correct
>>> review. This has proved to be very effective in that I am finally
>>> getting complete closure on some of these points.
>>>
>>> There cannot possibly exist any H(D,D) that is called by
>>> D where H(D,D) simulates its input and D(D) stops running
>>> and H never aborts its simulation.
>>>
>>
>> Right, because Halting Deciders have been proven impossible.
>>
>
> They are only impossible because:
> (a) They are required to correctly answer incorrect questions.

What is "Incorrect" about the question?

Which exact instance of the quesiton has no answer, or presumes
something incorrect?

Remember, there is no presumption that any given decider can answer the
question, despite what you might be trying to claim.

Also, H^ in the question is a FIXED compution, based on a FIXED H, so
arguing about a changed H has that changed H still seeing the same input.

So, if H^ is built on an H that does abort, and H is then "changed" to
one that doesn't, that NEW H will get the right answer, not show that
the original was correct to say non-halting.

>
> (b) They are required to be clairvoyant reporting on behavior
> different than the behavior that they actually see.

What rule of Questions says that you can only ask about what a decider
can see?

That seems to be you fundamental error.

>
>> You keep on proving that, and then claim that you have a way to refute
>> that, but you seem to think asserting it will refute it.
>>
>> That isn't the way logic works.
>>
>> And H(D,D) not giving the right answer doesn't mean that there isn't a
>> right answer.
>>
>> After all, Truth is Truth, even if no one knows it.
>>
>> Something that seem strange to you because you confuse Truth and
>> Knowledge.
>

On 3/16/24 12:19 PM, olcott wrote:
> On 3/16/2024 12:31 PM, immibis wrote:
>> On 16/03/24 15:51, olcott wrote:
>>> I keep posting the same point until it gets a complete and correct
>>> review. This has proved to be very effective in that I am finally
>>> getting complete closure on some of these points.
>>>
>>> There cannot possibly exist any H(D,D) that is called by
>>> D where H(D,D) simulates its input and D(D) stops running
>>> and H never aborts its simulation.
>>>
>>
>> These words don't mean anything.
>
> Since all words always mean something why lie?
>
Nope.

What does "Earth bracket thingamabob" mean?

Now, Your statement does have a meaning, but doesn't prove your thesis,
so, for the thesis, it is meaningless.

The fact that NO H can get the correct answer to the version of the
question based on it say NOTHING about the validity of the question that
doesn't refer to the decider.

You are just proving how incorrect your concept of reasoning is.

On 16/03/24 20:58, olcott wrote:
> On 3/16/2024 2:56 PM, immibis wrote:
>> On 16/03/24 19:19, olcott wrote:
>>> On 3/16/2024 12:30 PM, immibis wrote:
>>>> On 16/03/24 16:28, olcott wrote:
>>>>> 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 purpose of a halting decider is to be clairvoyant. A halting
>>>> decider must decide that a program will never halt even if we run it
>>>> forever, without actually running it forever.
>>>>
>>> Not at all. Something like mathematical induction accurately
>>> extrapolates what the future behavior would be:
>>
>> In other words: mathematical induction is clairvoyant.
>
> Not at all. Mathematical induction extrapolates on the basis of
> what it sees. Requiring H(D,D) to report on behavior that it cannot
> even see is incorrect.

In other words: Mathematical induction reports on behaviour that it
cannot even see.

On 16/03/24 00:37, 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).
>
> PO understanding:  When PO reads "prevent H from doing xxxxx" he thinks
> we change the C code of H to H' (which /in PO's x86utm/ system entails
> also changing D to D'), and then restart everything so we are looking at
> H' deciding (D',D') - a totally different input.  He then notes that
> D'(D') doesn't halt, so concludes (outer) H is right to decide
> non-halting on the ground that D'(D') runs forever. Same PO thinking
> applies to all his duffer "conditionals" in his phrases like "what H
> /would/ do...", and "halts /only/ because...".
>
> Things that reinforce PO's wrong thinking:
> -  His x86utm.exe design confuses the distinction between code and data.
>    H and D are both CODE (like TMs) when called from main(), but when
> passed as
>    parameters to H or D, and when simulated, they are logically DATA.
>    Perhaps if PO had designed x86utm "properly" and not confused these
> notions
>    in his x86utm design, he would have realised that discussing
> alternative H
>    behaviours was purely a CODE matter, and the input (P,I), being
> DATA, does not
>    magically change as a result of any H coding change...
> -  Since PO does not physically embed H logic into C function D() , and
> instead just
>    calls H, PO probably fails to consider that changing H is also
> changing D.  Also
>    the fact that as parameters in halt7.c they appear just as "H" and
> "D" obscuring the
>    fact that D is not just the code in D but also includes all the H code.
>
> With PO's choices for x86utm design, we can't just simply evaluate PO's
> duffer conditionals by updating H, recompiling and rerunning [since that
> would be changing code AND INPUT DATA].  A couple of ways to do it
> "properly" within PO's current design:
> -  keep H and D unchanged, but implement the updated H as H2.  Then we
> can examine H2(D,D),
>    while the input (D,D) being examined is not changed.  As with PO's
> H1(D,D), H2 will see
>    the simulated D(D) terminate.
> -  Examine H(D,D) (no code changes) but under a debugger.  When [outer]
> H goes to abort,
>    use the debugger to jump H over the abort and let things continue.
>    That's a bit fiddly, as the program being debugged is x86utm, not H,
> but I gave it a
>    go to settle this argument once and for all.  :)  As we all would
> expect,
>    H goes on to examine the full D(D) simulation instead of aborting,
> AND OBSERVES
>    THAT D(D) HALTS.
>    So now it's confirmed!  What H "would" do if it didn't abort its
> simulation of D(D)
>    is "continue simulating until it see D(D) halt".  So H has not
> "correctly seen
>    that its input would not halt unless aborted".  (PO won't understand
> though.)
>
>
> Mike.
>

On 3/16/24 9:56 AM, olcott wrote:
> On 3/16/2024 11:45 AM, Richard Damon wrote:
>> On 3/16/24 9:31 AM, olcott wrote:
>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>
>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>> On 3/15/2024 1:45 PM, 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,
>>>>>>>>>
>>>>>>>>> I was baffled by this for three days when I first investigated
>>>>>>>>> this.
>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>> see that
>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>> them abort.
>>>>>>>>
>>>>>>>> And thus you look at a strawman. A case where H isn't the H that
>>>>>>>> we started with.
>>>>>>>>
>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>> asked.
>>>>>>>>
>>>>>>>
>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>> has already aborted the simulation of its input at the point
>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>> for this H(D,D).
>>>>>>
>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>> you need to reference in the proof.
>>>>>>
>>>>>
>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>> that H correctly determined that it had to abort the simulation
>>>>> of its input to prevent the infinite execution of this input.
>>>>>
>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>> and H never aborts its simulation.
>>>>>
>>>>>
>>>>
>>>> Except that it THIS H actually DID need to abort its simulation,
>>>> then when we run the input, it should not halt.
>>>>
>>>
>>>  >>>Except that it THIS H actually DID need to abort its simulation<<<
>>> Then it aborts its simulation.
>>>
>>> Wrong
>>>  >>>then when we run the input, it should not halt.<<<
>>>
>>> then when we run the input, (after H aborts its simulation)
>>> it should halt.
>>>
>>>
>>>
>>
>> WRONG.
>>
>> Is the call to H from main the same function invocation as the call to
>> H from D?
>>
>> NO, They are different stack frames and thus DIFFERENT invocations.
>>
>
> *The timing is different*
> In both cases H(D,D) must abort the simulation of its input to prevent
> the infinite execution of this input.
>
> void main() { D(D); };
> reaps the benefit of this correct decision by H(D,D).
>
> void main() { H(D,D); };
> cannot reap this same benefit because of the difference in timing.

On 3/16/2024 5:03 PM, immibis wrote:
> On 16/03/24 00:37, 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).
>>
>> PO understanding:  When PO reads "prevent H from doing xxxxx" he
>> thinks we change the C code of H to H' (which /in PO's x86utm/ system
>> entails also changing D to D'), and then restart everything so we are
>> looking at H' deciding (D',D') - a totally different input.  He then
>> notes that D'(D') doesn't halt, so concludes (outer) H is right to
>> decide non-halting on the ground that D'(D') runs forever. Same PO
>> thinking applies to all his duffer "conditionals" in his phrases like
>> "what H /would/ do...", and "halts /only/ because...".
>>
>> Things that reinforce PO's wrong thinking:
>> -  His x86utm.exe design confuses the distinction between code and data.
>>     H and D are both CODE (like TMs) when called from main(), but when
>> passed as
>>     parameters to H or D, and when simulated, they are logically DATA.
>>     Perhaps if PO had designed x86utm "properly" and not confused
>> these notions
>>     in his x86utm design, he would have realised that discussing
>> alternative H
>>     behaviours was purely a CODE matter, and the input (P,I), being
>> DATA, does not
>>     magically change as a result of any H coding change...
>> -  Since PO does not physically embed H logic into C function D() ,
>> and instead just
>>     calls H, PO probably fails to consider that changing H is also
>> changing D.  Also
>>     the fact that as parameters in halt7.c they appear just as "H" and
>> "D" obscuring the
>>     fact that D is not just the code in D but also includes all the H
>> code.
>>
>> With PO's choices for x86utm design, we can't just simply evaluate
>> PO's duffer conditionals by updating H, recompiling and rerunning
>> [since that would be changing code AND INPUT DATA].  A couple of ways
>> to do it "properly" within PO's current design:
>> -  keep H and D unchanged, but implement the updated H as H2.  Then we
>> can examine H2(D,D),
>>     while the input (D,D) being examined is not changed.  As with PO's
>> H1(D,D), H2 will see
>>     the simulated D(D) terminate.
>> -  Examine H(D,D) (no code changes) but under a debugger.  When
>> [outer] H goes to abort,
>>     use the debugger to jump H over the abort and let things continue.
>>     That's a bit fiddly, as the program being debugged is x86utm, not
>> H, but I gave it a
>>     go to settle this argument once and for all.  :)  As we all would
>> expect,
>>     H goes on to examine the full D(D) simulation instead of aborting,
>> AND OBSERVES
>>     THAT D(D) HALTS.
>>     So now it's confirmed!  What H "would" do if it didn't abort its
>> simulation of D(D)
>>     is "continue simulating until it see D(D) halt".  So H has not
>> "correctly seen
>>     that its input would not halt unless aborted".  (PO won't
>> understand though.)
>>
>>
>> Mike.
>>
>
> It's a shame that Olcott didn't read your fantastic response beyond the
> part where you said he was wrong.

On 3/16/2024 4:09 PM, immibis wrote:
> On 16/03/24 20:58, olcott wrote:
>> On 3/16/2024 2:56 PM, immibis wrote:
>>> On 16/03/24 19:19, olcott wrote:
>>>> On 3/16/2024 12:30 PM, immibis wrote:
>>>>> On 16/03/24 16:28, olcott wrote:
>>>>>> 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 purpose of a halting decider is to be clairvoyant. A halting
>>>>> decider must decide that a program will never halt even if we run
>>>>> it forever, without actually running it forever.
>>>>>
>>>> Not at all. Something like mathematical induction accurately
>>>> extrapolates what the future behavior would be:
>>>
>>> In other words: mathematical induction is clairvoyant.
>>
>> Not at all. Mathematical induction extrapolates on the basis of
>> what it sees. Requiring H(D,D) to report on behavior that it cannot
>> even see is incorrect.
>
> In other words: Mathematical induction reports on behaviour that it
> cannot even see.

Extrapolating with no basis is not the same as extrapolating from
a basis. H(D,D) has no basis to report on directly executed D(D).

It has sufficient basis (N steps of D(D) correctly simulated by H)
to report on ∞ steps of D(D) correctly simulated by H.

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

On 3/16/2024 5:28 PM, Richard Damon wrote:
> On 3/16/24 9:56 AM, olcott wrote:
>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>> On 3/16/24 9:31 AM, olcott wrote:
>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>> On 3/15/2024 1:45 PM, 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,
>>>>>>>>>>
>>>>>>>>>> I was baffled by this for three days when I first investigated
>>>>>>>>>> this.
>>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>>> see that
>>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>>> them abort.
>>>>>>>>>
>>>>>>>>> And thus you look at a strawman. A case where H isn't the H
>>>>>>>>> that we started with.
>>>>>>>>>
>>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>>> asked.
>>>>>>>>>
>>>>>>>>
>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>> for this H(D,D).
>>>>>>>
>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>> you need to reference in the proof.
>>>>>>>
>>>>>>
>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>> that H correctly determined that it had to abort the simulation
>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>
>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>> and H never aborts its simulation.
>>>>>>
>>>>>>
>>>>>
>>>>> Except that it THIS H actually DID need to abort its simulation,
>>>>> then when we run the input, it should not halt.
>>>>>
>>>>
>>>>  >>>Except that it THIS H actually DID need to abort its simulation<<<
>>>> Then it aborts its simulation.
>>>>
>>>> Wrong
>>>>  >>>then when we run the input, it should not halt.<<<
>>>>
>>>> then when we run the input, (after H aborts its simulation)
>>>> it should halt.
>>>>
>>>>
>>>>
>>>
>>> WRONG.
>>>
>>> Is the call to H from main the same function invocation as the call
>>> to H from D?
>>>
>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>
>>
>> *The timing is different*
>> In both cases H(D,D) must abort the simulation of its input to prevent
>> the infinite execution of this input.
>>
>> void main() { D(D); };
>> reaps the benefit of this correct decision by H(D,D).
>>
>> void main() { H(D,D); };
>> cannot reap this same benefit because of the difference in timing.
>
> Why not?
>

On 3/16/2024 3:16 PM, Richard Damon wrote:
> On 3/16/24 9:36 AM, olcott wrote:
>> On 3/16/2024 10:51 AM, Richard Damon wrote:
>>> On 3/16/24 7:51 AM, olcott wrote:
>>>> On 3/16/2024 3:41 AM, Mikko wrote:
>>>>> On 2024-03-15 18:45:34 +0000, immibis said:
>>>>>
>>>>>> On 15/03/24 19:35, olcott wrote:
>>>>>>> On 3/15/2024 1:24 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 10:52 AM, 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 confuse the identities.
>>>>>>>>
>>>>>>>> *THIS* (the outer instance) doesn't need to abort its
>>>>>>>> simulation, because since the *OTHER* (the simulated version)
>>>>>>>> does, and thus the correct simulation of the input provided does
>>>>>>>> halt.
>>>>>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>> Posting the exact same message 5 times doesn't make it correct.
>>>>>
>>>>> But it makes the author look stupid, which may be the
>>>>> right thing to do.
>>>>>
>>>>
>>>> I keep posting the same point until it gets a complete and correct
>>>> review. This has proved to be very effective in that I am finally
>>>> getting complete closure on some of these points.
>>>>
>>>> There cannot possibly exist any H(D,D) that is called by
>>>> D where H(D,D) simulates its input and D(D) stops running
>>>> and H never aborts its simulation.
>>>>
>>>
>>> Right, because Halting Deciders have been proven impossible.
>>>
>>
>> They are only impossible because:
>> (a) They are required to correctly answer incorrect questions.
>
> What is "Incorrect" about the question?
>
> Which exact instance of the quesiton has no answer, or presumes
> something incorrect?
>
> Remember, there is no presumption that any given decider can answer the
> question, despite what you might be trying to claim.
>
> Also, H^ in the question is a FIXED compution, based on a FIXED H, so
> arguing about a changed H has that changed H still seeing the same input.
>
> So, if H^ is built on an H that does abort, and H is then "changed" to
> one that doesn't, that NEW H will get the right answer, not show that
> the original was correct to say non-halting.
>
>
>>
>> (b) They are required to be clairvoyant reporting on behavior
>> different than the behavior that they actually see.
>
> What rule of Questions says that you can only ask about what a decider
> can see?
>
> That seems to be you fundamental error.
>

On 3/16/24 12:03 PM, olcott wrote:
> On 3/16/2024 12:32 PM, immibis wrote:
>> On 16/03/24 17:56, olcott wrote:
>>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>>> On 3/16/24 9:31 AM, olcott wrote:
>>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 1:45 PM, 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,
>>>>>>>>>>>
>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>> investigated this.
>>>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>>>> see that
>>>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>>>> them abort.
>>>>>>>>>>
>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H
>>>>>>>>>> that we started with.
>>>>>>>>>>
>>>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>>>> asked.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>> for this H(D,D).
>>>>>>>>
>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>> you need to reference in the proof.
>>>>>>>>
>>>>>>>
>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>
>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>> and H never aborts its simulation.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except that it THIS H actually DID need to abort its simulation,
>>>>>> then when we run the input, it should not halt.
>>>>>>
>>>>>
>>>>>  >>>Except that it THIS H actually DID need to abort its simulation<<<
>>>>> Then it aborts its simulation.
>>>>>
>>>>> Wrong
>>>>>  >>>then when we run the input, it should not halt.<<<
>>>>>
>>>>> then when we run the input, (after H aborts its simulation)
>>>>> it should halt.
>>>>>
>>>>>
>>>>>
>>>>
>>>> WRONG.
>>>>
>>>> Is the call to H from main the same function invocation as the call
>>>> to H from D?
>>>>
>>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>>
>>>
>>> *The timing is different*
>>> In both cases H(D,D) must abort the simulation of its input to prevent
>>> the infinite execution of this input.
>>>
>>> void main() { D(D); };
>>> reaps the benefit of this correct decision by H(D,D).
>>>
>>> void main() { H(D,D); };
>>> cannot reap this same benefit because of the difference in timing.
>>>
>>> The behavior of D(D) before H(D,D) has aborted its simulation is
>>> different than the behavior of D(D) after H(D,D) has aborted its
>>> simulation.
>>>
>>>> Thus, the invocation from main didn't NEED to abort, because the
>>>> function is it simulating will terminate.
>>>>
>>>> The problem is your altered definition has actually created the
>>>> LIAR'S PARADOX that you claim the original version has (which it
>>>> doesn't).
>>>>
>>>> THAT makes the input not have a correct answer.
>>>>
>>>> To look at a changed H and call it H is just INCORRECT LOGIC, and a
>>>> LIE to perform.
>>>
>>
>> Turing machines don't have timing
>
> Sure they do.
>
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different result than Ĥ ⟨Ĥ⟩
> because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is executed :
> BEFORE it has aborted its simulation and Ĥ ⟨Ĥ⟩ is executed
> AFTER Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has aborted its simulation.
>

On 3/16/24 4:15 PM, olcott wrote:
> On 3/16/2024 5:28 PM, Richard Damon wrote:
>> On 3/16/24 9:56 AM, olcott wrote:
>>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>>> On 3/16/24 9:31 AM, olcott wrote:
>>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>> On 3/15/2024 1:45 PM, 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,
>>>>>>>>>>>
>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>> investigated this.
>>>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>>>> see that
>>>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>>>> them abort.
>>>>>>>>>>
>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H
>>>>>>>>>> that we started with.
>>>>>>>>>>
>>>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>>>> asked.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>> for this H(D,D).
>>>>>>>>
>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>> you need to reference in the proof.
>>>>>>>>
>>>>>>>
>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>
>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>> and H never aborts its simulation.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Except that it THIS H actually DID need to abort its simulation,
>>>>>> then when we run the input, it should not halt.
>>>>>>
>>>>>
>>>>>  >>>Except that it THIS H actually DID need to abort its simulation<<<
>>>>> Then it aborts its simulation.
>>>>>
>>>>> Wrong
>>>>>  >>>then when we run the input, it should not halt.<<<
>>>>>
>>>>> then when we run the input, (after H aborts its simulation)
>>>>> it should halt.
>>>>>
>>>>>
>>>>>
>>>>
>>>> WRONG.
>>>>
>>>> Is the call to H from main the same function invocation as the call
>>>> to H from D?
>>>>
>>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>>
>>>
>>> *The timing is different*
>>> In both cases H(D,D) must abort the simulation of its input to prevent
>>> the infinite execution of this input.
>>>
>>> void main() { D(D); };
>>> reaps the benefit of this correct decision by H(D,D).
>>>
>>> void main() { H(D,D); };
>>> cannot reap this same benefit because of the difference in timing.
>>
>> Why not?
>>
>
> Extrapolating with no basis is not the same as extrapolating from
> a basis. H(D,D) has no basis to report on directly executed D(D).

On 16/03/2024 22:03, immibis wrote:
> On 16/03/24 00:37, 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).
>>
>> PO understanding:  When PO reads "prevent H from doing xxxxx" he thinks we change the C code of H
>> to H' (which /in PO's x86utm/ system entails also changing D to D'), and then restart everything
>> so we are looking at H' deciding (D',D') - a totally different input.  He then notes that D'(D')
>> doesn't halt, so concludes (outer) H is right to decide non-halting on the ground that D'(D') runs
>> forever. Same PO thinking applies to all his duffer "conditionals" in his phrases like "what H
>> /would/ do...", and "halts /only/ because...".
>>
>> Things that reinforce PO's wrong thinking:
>> -  His x86utm.exe design confuses the distinction between code and data.
>>     H and D are both CODE (like TMs) when called from main(), but when passed as
>>     parameters to H or D, and when simulated, they are logically DATA.
>>     Perhaps if PO had designed x86utm "properly" and not confused these notions
>>     in his x86utm design, he would have realised that discussing alternative H
>>     behaviours was purely a CODE matter, and the input (P,I), being DATA, does not
>>     magically change as a result of any H coding change...
>> -  Since PO does not physically embed H logic into C function D() , and instead just
>>     calls H, PO probably fails to consider that changing H is also changing D.  Also
>>     the fact that as parameters in halt7.c they appear just as "H" and "D" obscuring the
>>     fact that D is not just the code in D but also includes all the H code.
>>
>> With PO's choices for x86utm design, we can't just simply evaluate PO's duffer conditionals by
>> updating H, recompiling and rerunning [since that would be changing code AND INPUT DATA].  A
>> couple of ways to do it "properly" within PO's current design:
>> -  keep H and D unchanged, but implement the updated H as H2.  Then we can examine H2(D,D),
>>     while the input (D,D) being examined is not changed.  As with PO's H1(D,D), H2 will see
>>     the simulated D(D) terminate.
>> -  Examine H(D,D) (no code changes) but under a debugger.  When [outer] H goes to abort,
>>     use the debugger to jump H over the abort and let things continue.
>>     That's a bit fiddly, as the program being debugged is x86utm, not H, but I gave it a
>>     go to settle this argument once and for all.  :)  As we all would expect,
>>     H goes on to examine the full D(D) simulation instead of aborting, AND OBSERVES
>>     THAT D(D) HALTS.
>>     So now it's confirmed!  What H "would" do if it didn't abort its simulation of D(D)
>>     is "continue simulating until it see D(D) halt".  So H has not "correctly seen
>>     that its input would not halt unless aborted".  (PO won't understand though.)
>>
>>
>> Mike.
>>
>
> It's a shame that Olcott didn't read your fantastic response beyond the part where you said he was
> wrong.

On 3/16/2024 6:31 PM, Richard Damon wrote:
> On 3/16/24 12:03 PM, olcott wrote:
>> On 3/16/2024 12:32 PM, immibis wrote:
>>> On 16/03/24 17:56, olcott wrote:
>>>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>>>> On 3/16/24 9:31 AM, olcott wrote:
>>>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2024 1:45 PM, 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,
>>>>>>>>>>>>
>>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>>> investigated this.
>>>>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>>>>> see that
>>>>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>>>>> them abort.
>>>>>>>>>>>
>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H
>>>>>>>>>>> that we started with.
>>>>>>>>>>>
>>>>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>>>>> asked.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>> for this H(D,D).
>>>>>>>>>
>>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>>> you need to reference in the proof.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>
>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>> and H never aborts its simulation.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Except that it THIS H actually DID need to abort its simulation,
>>>>>>> then when we run the input, it should not halt.
>>>>>>>
>>>>>>
>>>>>>  >>>Except that it THIS H actually DID need to abort its
>>>>>> simulation<<<
>>>>>> Then it aborts its simulation.
>>>>>>
>>>>>> Wrong
>>>>>>  >>>then when we run the input, it should not halt.<<<
>>>>>>
>>>>>> then when we run the input, (after H aborts its simulation)
>>>>>> it should halt.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> WRONG.
>>>>>
>>>>> Is the call to H from main the same function invocation as the call
>>>>> to H from D?
>>>>>
>>>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>>>
>>>>
>>>> *The timing is different*
>>>> In both cases H(D,D) must abort the simulation of its input to prevent
>>>> the infinite execution of this input.
>>>>
>>>> void main() { D(D); };
>>>> reaps the benefit of this correct decision by H(D,D).
>>>>
>>>> void main() { H(D,D); };
>>>> cannot reap this same benefit because of the difference in timing.
>>>>
>>>> The behavior of D(D) before H(D,D) has aborted its simulation is
>>>> different than the behavior of D(D) after H(D,D) has aborted its
>>>> simulation.
>>>>
>>>>> Thus, the invocation from main didn't NEED to abort, because the
>>>>> function is it simulating will terminate.
>>>>>
>>>>> The problem is your altered definition has actually created the
>>>>> LIAR'S PARADOX that you claim the original version has (which it
>>>>> doesn't).
>>>>>
>>>>> THAT makes the input not have a correct answer.
>>>>>
>>>>> To look at a changed H and call it H is just INCORRECT LOGIC, and a
>>>>> LIE to perform.
>>>>
>>>
>>> Turing machines don't have timing
>>
>> Sure they do.
>>
>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets a different result than Ĥ ⟨Ĥ⟩
>> because Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is executed :
>> BEFORE it has aborted its simulation and Ĥ ⟨Ĥ⟩ is executed
>> AFTER Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ has aborted its simulation.
>>
>
> Nope.
>
> Show an example as an actual Turing Machine, or you are just a liar.

On 3/16/2024 6:27 PM, Mike Terry wrote:
> On 16/03/2024 22:03, immibis wrote:
>> On 16/03/24 00:37, 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).
>>>
>>> PO understanding:  When PO reads "prevent H from doing xxxxx" he
>>> thinks we change the C code of H to H' (which /in PO's x86utm/ system
>>> entails also changing D to D'), and then restart everything so we are
>>> looking at H' deciding (D',D') - a totally different input.  He then
>>> notes that D'(D') doesn't halt, so concludes (outer) H is right to
>>> decide non-halting on the ground that D'(D') runs forever. Same PO
>>> thinking applies to all his duffer "conditionals" in his phrases like
>>> "what H /would/ do...", and "halts /only/ because...".
>>>
>>> Things that reinforce PO's wrong thinking:
>>> -  His x86utm.exe design confuses the distinction between code and data.
>>>     H and D are both CODE (like TMs) when called from main(), but
>>> when passed as
>>>     parameters to H or D, and when simulated, they are logically DATA.
>>>     Perhaps if PO had designed x86utm "properly" and not confused
>>> these notions
>>>     in his x86utm design, he would have realised that discussing
>>> alternative H
>>>     behaviours was purely a CODE matter, and the input (P,I), being
>>> DATA, does not
>>>     magically change as a result of any H coding change...
>>> -  Since PO does not physically embed H logic into C function D() ,
>>> and instead just
>>>     calls H, PO probably fails to consider that changing H is also
>>> changing D.  Also
>>>     the fact that as parameters in halt7.c they appear just as "H"
>>> and "D" obscuring the
>>>     fact that D is not just the code in D but also includes all the H
>>> code.
>>>
>>> With PO's choices for x86utm design, we can't just simply evaluate
>>> PO's duffer conditionals by updating H, recompiling and rerunning
>>> [since that would be changing code AND INPUT DATA].  A couple of ways
>>> to do it "properly" within PO's current design:
>>> -  keep H and D unchanged, but implement the updated H as H2.  Then
>>> we can examine H2(D,D),
>>>     while the input (D,D) being examined is not changed.  As with
>>> PO's H1(D,D), H2 will see
>>>     the simulated D(D) terminate.
>>> -  Examine H(D,D) (no code changes) but under a debugger.  When
>>> [outer] H goes to abort,
>>>     use the debugger to jump H over the abort and let things continue.
>>>     That's a bit fiddly, as the program being debugged is x86utm, not
>>> H, but I gave it a
>>>     go to settle this argument once and for all.  :)  As we all would
>>> expect,
>>>     H goes on to examine the full D(D) simulation instead of
>>> aborting, AND OBSERVES
>>>     THAT D(D) HALTS.
>>>     So now it's confirmed!  What H "would" do if it didn't abort its
>>> simulation of D(D)
>>>     is "continue simulating until it see D(D) halt".  So H has not
>>> "correctly seen
>>>     that its input would not halt unless aborted".  (PO won't
>>> understand though.)
>>>
>>>
>>> Mike.
>>>
>>
>> It's a shame that Olcott didn't read your fantastic response beyond
>> the part where you said he was wrong.
>
> PO can be very selective in what he absorbs from other people!  E.g. I
> could write what I consider a thorough review of PO's various errors,
> carefully explained etc., and PO will likely blank it all, maybe picking
> out one phrase he thinks useful and thanking me for confirming something
> which (in his mind) he has been battling other people over for years!  I
> actually chuckle when he does that, where in my earlier dealings with PO
> I would have been annoyed.
>
> Anyhow, it's all been said to PO many times before, which is why I have
> no expectation PO will suddenly see the light.  And thanks - it's nice
> to know someone appreciated the post :)
>
>
> Mike.
>

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" ?
>

On 3/16/2024 6:34 PM, Richard Damon wrote:
> On 3/16/24 4:15 PM, olcott wrote:
>> On 3/16/2024 5:28 PM, Richard Damon wrote:
>>> On 3/16/24 9:56 AM, olcott wrote:
>>>> On 3/16/2024 11:45 AM, Richard Damon wrote:
>>>>> On 3/16/24 9:31 AM, olcott wrote:
>>>>>> On 3/16/2024 11:22 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 7:48 AM, olcott wrote:
>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2024 1:45 PM, 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,
>>>>>>>>>>>>
>>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>>> investigated this.
>>>>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>>>>> see that
>>>>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>>>>> them abort.
>>>>>>>>>>>
>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H
>>>>>>>>>>> that we started with.
>>>>>>>>>>>
>>>>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>>>>> asked.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>> for this H(D,D).
>>>>>>>>>
>>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>>> you need to reference in the proof.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>
>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>> and H never aborts its simulation.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Except that it THIS H actually DID need to abort its simulation,
>>>>>>> then when we run the input, it should not halt.
>>>>>>>
>>>>>>
>>>>>>  >>>Except that it THIS H actually DID need to abort its
>>>>>> simulation<<<
>>>>>> Then it aborts its simulation.
>>>>>>
>>>>>> Wrong
>>>>>>  >>>then when we run the input, it should not halt.<<<
>>>>>>
>>>>>> then when we run the input, (after H aborts its simulation)
>>>>>> it should halt.
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>> WRONG.
>>>>>
>>>>> Is the call to H from main the same function invocation as the call
>>>>> to H from D?
>>>>>
>>>>> NO, They are different stack frames and thus DIFFERENT invocations.
>>>>>
>>>>
>>>> *The timing is different*
>>>> In both cases H(D,D) must abort the simulation of its input to prevent
>>>> the infinite execution of this input.
>>>>
>>>> void main() { D(D); };
>>>> reaps the benefit of this correct decision by H(D,D).
>>>>
>>>> void main() { H(D,D); };
>>>> cannot reap this same benefit because of the difference in timing.
>>>
>>> Why not?
>>>
>>
>> Extrapolating with no basis is not the same as extrapolating from
>> a basis. H(D,D) has no basis to report on directly executed D(D).
>
> So?
>
>>
>> It has sufficient basis (N steps of D(D) correctly simulated by H)
>> to report on ∞ steps of D(D) correctly simulated by H.
>
> How?
>

On 3/16/24 9:38 AM, olcott wrote:
> On 3/16/2024 11:35 AM, immibis wrote:

>> ERROR is not the exact same result as the conventional halting criteria.
>
> Because the conventional criteria requires:
>
> (a) Halt deciders to correctly answer incorrect questions.

Nope, and you can't show a reason it is invalid.

Every input has a correct answer.

Your repeating that just shows you to be a liar.

>
> (b) Halt deciders to be clairvoyant reporting on behavior
> different than the behavior that they actually see.

No, that might be a reason it has problems, but the problem has well
defined definition.

You just don't understand what truth means.

>
>>
>>>
>>>>
>>>>>> So, you are still the liar.
>>>>>>
>>>>>
>>>>
>>>
>>
>

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,