On 3/15/24 12:40 PM, olcott wrote:
> 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).
>

So, you admit to using a false definition of "Correct Simulation" and
thus lying about H meeting the criteria.

Correct Simulation (in Computation theory) ALWAYS continue the machine
reaches a final state.

So, you are just admitting to being a LIAR.

On 3/15/24 12:38 PM, olcott wrote:
> On 3/15/2024 2:30 PM, Richard Damon wrote:
>> On 3/15/24 12:14 PM, olcott wrote:
>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>> On 3/15/24 11:39 AM, 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.
>>>>>
>>>>
>>>> But since it does, which is your definition of H, the others
>>>
>>> never begin to be simulated.
>>
>> But D(D) started to be simulated, and we can know what D(D) actually
>> does, which includes it using its version of H.
>>
>
> 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).
>

WHy not?

That is what Correct Simulation refers to.

I guess you are just admiting to being a LIAR (or stupid).

On 3/15/2024 3:24 PM, Richard Damon wrote:
> On 3/15/24 12:42 PM, olcott wrote:
>> On 3/15/2024 2:27 PM, Richard Damon wrote:
>>> On 3/15/24 12:10 PM, olcott wrote:
>>>> On 3/15/2024 1:59 PM, Richard Damon wrote:
>>>>> On 3/15/24 11:35 AM, 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.
>>>>>>
>>>>>
>>>>> No, it doesn't. It sees that your incorrect implementation of that
>>>>> requirement is meet, and thus gives the wrong answer.
>>>>>
>>>>> H1 shows that the correct simuation of the input to D (which is
>>>>> what the criteria you quote looks at) does stop and thus H did not
>>>>> meet its requirements to use step b, but did so anyway.
>>>>>
>>>>> H DECIEVES ITSELF, by imagining it is something it isn't in a way
>>>>> that changes the input to something it isn't and answer, correctly
>>>>> for the wrong question, and thus lies. Just a you do for calling it
>>>>> correct.
>>>>>
>>>>> If the H that you claim is correct does abort, then D uses that H
>>>>> that does that, and thus H's logic is unsound.
>>>>
>>>> It is an easily verified fact that if no H(D,D) aborts its
>>>> simulation that D(D) never halts.
>>>
>>> Right, but EVERY H(D,D) aborts so your condition isn't satified and
>>> your arguement is unsound, just like most of your statments.
>>
>> 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).
>>
>> H(D,D)==0 is correct meaning that the abort criteria has been met.
>>
>
> Why can we not refenerence the behavior of what D(D) does after H(D,D)
> aborts it?
>

It is a fact that the behavior of D(D) after it aborts
its simulation cannot be used as abort status criteria or
no H(D,D) would ever abort its simulation.

--
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/15/24 1:16 PM, olcott wrote:

> To the best of my current knowledge all of your rebuttals
> to this relied on counter-factual assumptions that cannot
> possibly be supported with correct reasoning because they
> are counter-factual.
>

Which is a meaningless subjective statement

Since you fail to ever point out an actual couter-factual assumption,
this is just a statement of your own opinion, which has proved to be a
VERY BAD predictor of reality.

This just shows that you are, in fact, just a pathological liar, as you
refuse to evaluate what is actually true vs what you think is true.

This shows that you concept of "Correct Reasoning" is almost certainly a
DEAD SUBJECT.

You are just admitting that you work is worthless and that you are not
intereset in Honest Dialog, but just want to do your own Monolog and get
annoyed that people are pointing out your errors.

If that is REALLY what you want to be know for, knock yourself out, we
can just keep on piling on the proof that you are just the pathetic
ignorant hypocritical pathological lying idiot that you show yourself to be.

On 3/15/24 1:37 PM, olcott wrote:
> On 3/15/2024 3:24 PM, Richard Damon wrote:
>> On 3/15/24 12:42 PM, olcott wrote:
>>> On 3/15/2024 2:27 PM, Richard Damon wrote:
>>>> On 3/15/24 12:10 PM, olcott wrote:
>>>>> On 3/15/2024 1:59 PM, Richard Damon wrote:
>>>>>> On 3/15/24 11:35 AM, 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.
>>>>>>>
>>>>>>
>>>>>> No, it doesn't. It sees that your incorrect implementation of that
>>>>>> requirement is meet, and thus gives the wrong answer.
>>>>>>
>>>>>> H1 shows that the correct simuation of the input to D (which is
>>>>>> what the criteria you quote looks at) does stop and thus H did not
>>>>>> meet its requirements to use step b, but did so anyway.
>>>>>>
>>>>>> H DECIEVES ITSELF, by imagining it is something it isn't in a way
>>>>>> that changes the input to something it isn't and answer, correctly
>>>>>> for the wrong question, and thus lies. Just a you do for calling
>>>>>> it correct.
>>>>>>
>>>>>> If the H that you claim is correct does abort, then D uses that H
>>>>>> that does that, and thus H's logic is unsound.
>>>>>
>>>>> It is an easily verified fact that if no H(D,D) aborts its
>>>>> simulation that D(D) never halts.
>>>>
>>>> Right, but EVERY H(D,D) aborts so your condition isn't satified and
>>>> your arguement is unsound, just like most of your statments.
>>>
>>> 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).
>>>
>>> H(D,D)==0 is correct meaning that the abort criteria has been met.
>>>
>>
>> Why can we not refenerence the behavior of what D(D) does after H(D,D)
>> aborts it?
>>
>
> It is a fact that the behavior of D(D) after it aborts
> its simulation cannot be used as abort status criteria or
> no H(D,D) would ever abort its simulation.
>

On 3/15/2024 3:41 PM, Richard Damon wrote:
> On 3/15/24 1:16 PM, olcott wrote:
>
>> To the best of my current knowledge all of your rebuttals
>> to this relied on counter-factual assumptions that cannot
>> possibly be supported with correct reasoning because they
>> are counter-factual.
>>
>
> Which is a meaningless subjective statement
>
> Since you fail to ever point out an actual couter-factual assumption,

*I pointed out the facts and you disagreed*
(a) The behavior of every H(D,D) is identical because it is the same
code and data.

(b) The executed H(D,D) always has at least one execution trace more
data than any of its simulated instances.

(c) This entails that the executed H(D,D) sees its abort status criteria
sooner than any of its simulated instances.

(d) We assume (the design criteria) that each H(D,D) aborts its
simulation as soon as its abort status criteria has been met.

(e) (a)(b)(c)(d) Entail that unless the executed H(D,D) aborts its
simulation that none of the simulated instances of H(D,D) ever will.

--
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/15/2024 3:43 PM, Richard Damon wrote:
> On 3/15/24 1:37 PM, olcott wrote:
>> On 3/15/2024 3:24 PM, Richard Damon wrote:
>>> On 3/15/24 12:42 PM, olcott wrote:
>>>> On 3/15/2024 2:27 PM, Richard Damon wrote:
>>>>> On 3/15/24 12:10 PM, olcott wrote:
>>>>>> On 3/15/2024 1:59 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 11:35 AM, 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.
>>>>>>>>
>>>>>>>
>>>>>>> No, it doesn't. It sees that your incorrect implementation of
>>>>>>> that requirement is meet, and thus gives the wrong answer.
>>>>>>>
>>>>>>> H1 shows that the correct simuation of the input to D (which is
>>>>>>> what the criteria you quote looks at) does stop and thus H did
>>>>>>> not meet its requirements to use step b, but did so anyway.
>>>>>>>
>>>>>>> H DECIEVES ITSELF, by imagining it is something it isn't in a way
>>>>>>> that changes the input to something it isn't and answer,
>>>>>>> correctly for the wrong question, and thus lies. Just a you do
>>>>>>> for calling it correct.
>>>>>>>
>>>>>>> If the H that you claim is correct does abort, then D uses that H
>>>>>>> that does that, and thus H's logic is unsound.
>>>>>>
>>>>>> It is an easily verified fact that if no H(D,D) aborts its
>>>>>> simulation that D(D) never halts.
>>>>>
>>>>> Right, but EVERY H(D,D) aborts so your condition isn't satified and
>>>>> your arguement is unsound, just like most of your statments.
>>>>
>>>> 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).
>>>>
>>>> H(D,D)==0 is correct meaning that the abort criteria has been met.
>>>>
>>>
>>> Why can we not refenerence the behavior of what D(D) does after
>>> H(D,D) aborts it?
>>>
>>
>> It is a fact that the behavior of D(D) after it aborts
>> its simulation cannot be used as abort status criteria or
>> no H(D,D) would ever abort its simulation.
>>
>
> Yes, that is a correct computational argument, but doesn't prove the
> criteria used is correct.
>
Finally a breakthrough.

On 3/15/2024 3:27 PM, Richard Damon wrote:
> On 3/15/24 12:38 PM, olcott wrote:
>> On 3/15/2024 2:30 PM, Richard Damon wrote:
>>> On 3/15/24 12:14 PM, olcott wrote:
>>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>>> On 3/15/24 11:39 AM, 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.
>>>>>>
>>>>>
>>>>> But since it does, which is your definition of H, the others
>>>>
>>>> never begin to be simulated.
>>>
>>> But D(D) started to be simulated, and we can know what D(D) actually
>>> does, which includes it using its version of H.
>>>
>>
>> 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).
>>
>
> WHy not?
>
> That is what Correct Simulation refers to.
>
> I guess you are just admiting to being a LIAR (or stupid).

*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*
*I am not a liar or stupid and you admitted your mistake*

On 3/15/2024 3:43 PM, Richard Damon wrote:
> On 3/15/24 1:37 PM, olcott wrote:
>>
>> It is a fact that the behavior of D(D) after it aborts
>> its simulation cannot be used as abort status criteria or
>> no H(D,D) would ever abort its simulation.
>>
>
> Yes, that is a correct computational argument, but doesn't prove the
> criteria used is correct.
>

--
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/15/24 2:02 PM, olcott wrote:
> On 3/15/2024 3:41 PM, Richard Damon wrote:
>> On 3/15/24 1:16 PM, olcott wrote:
>>
>>> To the best of my current knowledge all of your rebuttals
>>> to this relied on counter-factual assumptions that cannot
>>> possibly be supported with correct reasoning because they
>>> are counter-factual.
>>>
>>
>> Which is a meaningless subjective statement
>>
>> Since you fail to ever point out an actual couter-factual assumption,
>
>
> *I pointed out the facts and you disagreed*
> (a) The behavior of every H(D,D) is identical because it is the same
> code and data.
>
Agreed. But that is the FINAL H decided on, since that is the only one
that actually exists and D is claimed to be like the H^ in Linz proof

> (b) The executed H(D,D) always has at least one execution trace more
> data than any of its simulated instances.

False. Only true at a given instant of a given H's simulation.

ALL H's will eventually see that exact same data.

>
> (c) This entails that the executed H(D,D) sees its abort status criteria
> sooner than any of its simulated instances.

True. Sooner, but the ALL will when we look at the ACTUAL BEHAVIOR of
the machine being simulated.

>
> (d) We assume (the design criteria) that each H(D,D) aborts its
> simulation as soon as its abort status criteria has been met.

Ok, but that doesn't prove any given stated conditions are correct.

>
> (e) (a)(b)(c)(d) Entail that unless the executed H(D,D) aborts its
> simulation that none of the simulated instances of H(D,D) ever will.
>

UNSOUND ARGUMENT. You can't "Assume" that H doesn't abort, since it
does. You don't understand the logical meaning of "unless"

Since H DOES abort its simulation then by (a) ALL WILL.

If we hypothyse looking at the ACTUAL CORRECT SIMULATION of the input to
H, which is what the abort critera SAYS it is looking at.

We see that since we will eventually decide to abort, all copies of H
will abort, and thus that simulation will come to a halt.

THEREFORE, just because we decide to abort, we can not conclude that
this aborting is correct.

It is a DIFFERENT input when we change H to not abort, and thus it is
UNSOUND to look at it.

So, what is wrong with my counter claims?

In particular, you are not allowed to "just change H" as that changes
the nature of the question being asked.

You can't answer about how many cats you have, by looking at how many
dogs you have.

On 3/15/2024 4:15 PM, Richard Damon wrote:
> On 3/15/24 2:02 PM, olcott wrote:
>> On 3/15/2024 3:41 PM, Richard Damon wrote:
>>> On 3/15/24 1:16 PM, olcott wrote:
>>>
>>>> To the best of my current knowledge all of your rebuttals
>>>> to this relied on counter-factual assumptions that cannot
>>>> possibly be supported with correct reasoning because they
>>>> are counter-factual.
>>>>
>>>
>>> Which is a meaningless subjective statement
>>>
>>> Since you fail to ever point out an actual couter-factual assumption,
>>
>>
>> *I pointed out the facts and you disagreed*
>> (a) The behavior of every H(D,D) is identical because it is the same
>> code and data.
>>
> Agreed. But that is the FINAL H decided on, since that is the only one
> that actually exists and D is claimed to be like the H^ in Linz proof
>
>> (b) The executed H(D,D) always has at least one execution trace more
>> data than any of its simulated instances.
>
> False. Only true at a given instant of a given H's simulation.
>
At each point in any actual execution trace...
Fantasy traces that cannot possibly occur don't count.

> ALL H's will eventually see that exact same data.
>
>>
>> (c) This entails that the executed H(D,D) sees its abort status criteria
>> sooner than any of its simulated instances.
>
> True. Sooner, but the ALL will when we look at the ACTUAL BEHAVIOR of
> the machine being simulated.
>

On 3/15/2024 3:43 PM, Richard Damon wrote:
> On 3/15/24 1:37 PM, olcott wrote:
>>
>> It is a fact that the behavior of D(D) after it aborts
>> its simulation cannot be used as abort status criteria or
>> no H(D,D) would ever abort its simulation.
>>
>
> Yes, that is a correct computational argument, but doesn't prove the
> criteria used is correct.
>

>>
>> (d) We assume (the design criteria) that each H(D,D) aborts its
>> simulation as soon as its abort status criteria has been met.
>
> Ok, but that doesn't prove any given stated conditions are correct.
>
This is a simplifying assumption to make my explanation
less convoluted.

>>
>> (e) (a)(b)(c)(d) Entail that unless the executed H(D,D) aborts its
>> simulation that none of the simulated instances of H(D,D) ever will.
>>
>
> UNSOUND ARGUMENT. You can't "Assume" that H doesn't abort, since it
> does. You don't understand the logical meaning of "unless"
>

On 3/15/2024 3:43 PM, Richard Damon wrote:
> On 3/15/24 1:37 PM, olcott wrote:
>>
>> It is a fact that the behavior of D(D) after it aborts
>> its simulation cannot be used as abort status criteria or
>> no H(D,D) would ever abort its simulation.
>>
>
> Yes, that is a correct computational argument, but doesn't prove the
> criteria used is correct.
>

<snip you disagreeing with yourself>

--
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/15/24 2:13 PM, olcott wrote:
> On 3/15/2024 3:27 PM, Richard Damon wrote:
>> On 3/15/24 12:38 PM, olcott wrote:
>>> On 3/15/2024 2:30 PM, Richard Damon wrote:
>>>> On 3/15/24 12:14 PM, olcott wrote:
>>>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>>>> On 3/15/24 11:39 AM, 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.
>>>>>>>
>>>>>>
>>>>>> But since it does, which is your definition of H, the others
>>>>>
>>>>> never begin to be simulated.
>>>>
>>>> But D(D) started to be simulated, and we can know what D(D) actually
>>>> does, which includes it using its version of H.
>>>>
>>>
>>> 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).
>>>
>>
>> WHy not?
>>
>> That is what Correct Simulation refers to.
>>
>> I guess you are just admiting to being a LIAR (or stupid).
>
> *I am not a liar or stupid and you admitted your mistake*
> *I am not a liar or stupid and you admitted your mistake*
> *I am not a liar or stupid and you admitted your mistake*
> *I am not a liar or stupid and you admitted your mistake*

So, do you admit that the definition of a "Correct Simulation" for the
purposes of that criteria are the complete not-aborted simulation done
by possibly some other simulator?

Or are you admitting to lying? (since that IS the definition)

>
> On 3/15/2024 3:43 PM, Richard Damon wrote:
> > On 3/15/24 1:37 PM, olcott wrote:
> >>
> >> It is a fact that the behavior of D(D) after it aborts
> >> its simulation cannot be used as abort status criteria or
> >> no H(D,D) would ever abort its simulation.
> >>
> >
> > Yes, that is a correct computational argument, but doesn't prove the
> > criteria used is correct.
> >
>

On 3/15/24 2:26 PM, olcott wrote:
> On 3/15/2024 4:15 PM, Richard Damon wrote:
>> On 3/15/24 2:02 PM, olcott wrote:
>>> On 3/15/2024 3:41 PM, Richard Damon wrote:
>>>> On 3/15/24 1:16 PM, olcott wrote:
>>>>
>>>>> To the best of my current knowledge all of your rebuttals
>>>>> to this relied on counter-factual assumptions that cannot
>>>>> possibly be supported with correct reasoning because they
>>>>> are counter-factual.
>>>>>
>>>>
>>>> Which is a meaningless subjective statement
>>>>
>>>> Since you fail to ever point out an actual couter-factual assumption,
>>>
>>>
>>> *I pointed out the facts and you disagreed*
>>> (a) The behavior of every H(D,D) is identical because it is the same
>>> code and data.
>>>
>> Agreed. But that is the FINAL H decided on, since that is the only one
>> that actually exists and D is claimed to be like the H^ in Linz proof
>>
>>> (b) The executed H(D,D) always has at least one execution trace more
>>> data than any of its simulated instances.
>>
>> False. Only true at a given instant of a given H's simulation.
>>
> At each point in any actual execution trace...
> Fantasy traces that cannot possibly occur don't count.

But what DOES happen when the machine is actual run, do.

>
>> ALL H's will eventually see that exact same data.
>>
>>>
>>> (c) This entails that the executed H(D,D) sees its abort status criteria
>>> sooner than any of its simulated instances.
>>
>> True. Sooner, but the ALL will when we look at the ACTUAL BEHAVIOR of
>> the machine being simulated.
>>
>
> On 3/15/2024 3:43 PM, Richard Damon wrote:
> > On 3/15/24 1:37 PM, olcott wrote:
> >>
> >> It is a fact that the behavior of D(D) after it aborts
> >> its simulation cannot be used as abort status criteria or
> >> no H(D,D) would ever abort its simulation.
> >>
> >
> > Yes, that is a correct computational argument, but doesn't prove the
> > criteria used is correct.
> >

Right, H CAN only look at what it has done.

TRUTH is based on what WILL Happen (in the actual machines)

>
>>>
>>> (d) We assume (the design criteria) that each H(D,D) aborts its
>>> simulation as soon as its abort status criteria has been met.
>>
>> Ok, but that doesn't prove any given stated conditions are correct.
>>
> This is a simplifying assumption to make my explanation
> less convoluted.

But if it isn't a correct criteria, it is just in error.

You are not allowed to ignore the truth just because it is inconvient to
you.

>
>>>
>>> (e) (a)(b)(c)(d) Entail that unless the executed H(D,D) aborts its
>>> simulation that none of the simulated instances of H(D,D) ever will.
>>>
>>
>> UNSOUND ARGUMENT. You can't "Assume" that H doesn't abort, since it
>> does. You don't understand the logical meaning of "unless"
>>
>
> On 3/15/2024 3:43 PM, Richard Damon wrote:
> > On 3/15/24 1:37 PM, olcott wrote:
> >>
> >> It is a fact that the behavior of D(D) after it aborts
> >> its simulation cannot be used as abort status criteria or
> >> no H(D,D) would ever abort its simulation.
> >>
> >
> > Yes, that is a correct computational argument, but doesn't prove the
> > criteria used is correct.
> >
>
> <snip you disagreeing with yourself>
>

Nope.

You don't understand.

H CAN only determine based on what it has seen.

The CORRECT ANSWER depends on what the actual machine does, even if H
hasn't (or even can't) see that behavior.

H, to CORRECTLY determine the results of the correct simulation needs to
determine a results that AGREES with that correct simulation.

Since D(D) Halts, the ONLY thing that H could possible CORRECTLY
determine is Halting.

It has no actual proof of Halting (or not-Halting for that matter), so
it just doesn't know the right answer.

The proof shows that it CAN'T know (at least it can't know and answer to
that)

On 3/15/2024 5:10 PM, Richard Damon wrote:
> On 3/15/24 2:13 PM, olcott wrote:
>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>> On 3/15/24 12:38 PM, olcott wrote:
>>>> On 3/15/2024 2:30 PM, Richard Damon wrote:
>>>>> On 3/15/24 12:14 PM, olcott wrote:
>>>>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 11:39 AM, 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.
>>>>>>>>
>>>>>>>
>>>>>>> But since it does, which is your definition of H, the others
>>>>>>
>>>>>> never begin to be simulated.
>>>>>
>>>>> But D(D) started to be simulated, and we can know what D(D)
>>>>> actually does, which includes it using its version of H.
>>>>>
>>>>
>>>> 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).
>>>>
>>>
>>> WHy not?
>>>
>>> That is what Correct Simulation refers to.
>>>
>>> I guess you are just admiting to being a LIAR (or stupid).
>>
>> *I am not a liar or stupid and you admitted your mistake*
>> *I am not a liar or stupid and you admitted your mistake*
>> *I am not a liar or stupid and you admitted your mistake*
>> *I am not a liar or stupid and you admitted your mistake*
>
> So, do you admit that the definition of a "Correct Simulation" for the
> purposes of that criteria are the complete not-aborted simulation done
> by possibly some other simulator?
>

On 3/15/2024 5:19 PM, Richard Damon wrote:
> On 3/15/24 2:26 PM, olcott wrote:
>> On 3/15/2024 4:15 PM, Richard Damon wrote:
>>> On 3/15/24 2:02 PM, olcott wrote:
>>>> On 3/15/2024 3:41 PM, Richard Damon wrote:
>>>>> On 3/15/24 1:16 PM, olcott wrote:
>>>>>
>>>>>> To the best of my current knowledge all of your rebuttals
>>>>>> to this relied on counter-factual assumptions that cannot
>>>>>> possibly be supported with correct reasoning because they
>>>>>> are counter-factual.
>>>>>>
>>>>>
>>>>> Which is a meaningless subjective statement
>>>>>
>>>>> Since you fail to ever point out an actual couter-factual assumption,
>>>>
>>>>
>>>> *I pointed out the facts and you disagreed*
>>>> (a) The behavior of every H(D,D) is identical because it is the same
>>>> code and data.
>>>>
>>> Agreed. But that is the FINAL H decided on, since that is the only
>>> one that actually exists and D is claimed to be like the H^ in Linz
>>> proof
>>>
>>>> (b) The executed H(D,D) always has at least one execution trace more
>>>> data than any of its simulated instances.
>>>
>>> False. Only true at a given instant of a given H's simulation.
>>>
>> At each point in any actual execution trace...
>> Fantasy traces that cannot possibly occur don't count.
>
> But what DOES happen when the machine is actual run, do.
>

On 3/15/2024 3:43 PM, Richard Damon wrote:
> On 3/15/24 1:37 PM, olcott wrote:
>>
>> It is a fact that the behavior of D(D) after it aborts
>> its simulation cannot be used as abort status criteria or
>> no H(D,D) would ever abort its simulation.
>>
>
> Yes, that is a correct computational argument, but doesn't prove the
> criteria used is correct.
>

>>
>>> ALL H's will eventually see that exact same data.
>>>
>>>>
>>>> (c) This entails that the executed H(D,D) sees its abort status
>>>> criteria
>>>> sooner than any of its simulated instances.
>>>
>>> True. Sooner, but the ALL will when we look at the ACTUAL BEHAVIOR of
>>> the machine being simulated.
>>>
>>
>> On 3/15/2024 3:43 PM, Richard Damon wrote:
>>  > On 3/15/24 1:37 PM, olcott wrote:
>>  >>
>>  >> It is a fact that the behavior of D(D) after it aborts
>>  >> its simulation cannot be used as abort status criteria or
>>  >> no H(D,D) would ever abort its simulation.
>>  >>
>>  >
>>  > Yes, that is a correct computational argument, but doesn't prove the
>>  > criteria used is correct.
>>  >
>
> Right, H CAN only look at what it has done.
>

When it has done nothing yet it can't report on this.

> TRUTH is based on what WILL Happen (in the actual machines)
>
The correct abort criteria cannot do this or H(D,D) never halts.

>>
>>>>
>>>> (d) We assume (the design criteria) that each H(D,D) aborts its
>>>> simulation as soon as its abort status criteria has been met.
>>>
>>> Ok, but that doesn't prove any given stated conditions are correct.
>>>
>> This is a simplifying assumption to make my explanation
>> less convoluted.
>
> But if it isn't a correct criteria, it is just in error.
>
The paragraph was much more convoluted when we account for
every possible fixed number of execution traces rather than
simply picking the earliest decision point.

> You are not allowed to ignore the truth just because it is inconvient to
> you.
>
Likewise to you.

>>
>>>>
>>>> (e) (a)(b)(c)(d) Entail that unless the executed H(D,D) aborts its
>>>> simulation that none of the simulated instances of H(D,D) ever will.
>>>>
>>>
>>> UNSOUND ARGUMENT. You can't "Assume" that H doesn't abort, since it
>>> does. You don't understand the logical meaning of "unless"
>>>
>>
>> On 3/15/2024 3:43 PM, Richard Damon wrote:
>>  > On 3/15/24 1:37 PM, olcott wrote:
>>  >>
>>  >> It is a fact that the behavior of D(D) after it aborts
>>  >> its simulation cannot be used as abort status criteria or
>>  >> no H(D,D) would ever abort its simulation.
>>  >>
>>  >
>>  > Yes, that is a correct computational argument, but doesn't prove the
>>  > criteria used is correct.
>>  >
>>
>> <snip you disagreeing with yourself>
>>
>
> Nope.
>
> You don't understand.
>
> H CAN only determine based on what it has seen.
>

I do understand that. Even in this post you are trying to say
that H(D,D) must report on something that it would see rather
than what it has actually seen.

> The CORRECT ANSWER depends on what the actual machine does, even if H
> hasn't (or even can't) see that behavior.
>
You are contradicting yourself.

> H, to CORRECTLY determine the results of the correct simulation needs to
> determine a results that AGREES with that correct simulation.
>

(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

*H correctly simulates its input D until*
*requires that the simulation of a non-halting input*
*must be partial and cannot be complete*

--
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/15/24 3:59 PM, olcott wrote:
> On 3/15/2024 5:19 PM, Richard Damon wrote:
>> On 3/15/24 2:26 PM, olcott wrote:
>>> On 3/15/2024 4:15 PM, Richard Damon wrote:
>>>> On 3/15/24 2:02 PM, olcott wrote:
>>>>> On 3/15/2024 3:41 PM, Richard Damon wrote:
>>>>>> On 3/15/24 1:16 PM, olcott wrote:
>>>>>>
>>>>>>> To the best of my current knowledge all of your rebuttals
>>>>>>> to this relied on counter-factual assumptions that cannot
>>>>>>> possibly be supported with correct reasoning because they
>>>>>>> are counter-factual.
>>>>>>>
>>>>>>
>>>>>> Which is a meaningless subjective statement
>>>>>>
>>>>>> Since you fail to ever point out an actual couter-factual assumption,
>>>>>
>>>>>
>>>>> *I pointed out the facts and you disagreed*
>>>>> (a) The behavior of every H(D,D) is identical because it is the same
>>>>> code and data.
>>>>>
>>>> Agreed. But that is the FINAL H decided on, since that is the only
>>>> one that actually exists and D is claimed to be like the H^ in Linz
>>>> proof
>>>>
>>>>> (b) The executed H(D,D) always has at least one execution trace more
>>>>> data than any of its simulated instances.
>>>>
>>>> False. Only true at a given instant of a given H's simulation.
>>>>
>>> At each point in any actual execution trace...
>>> Fantasy traces that cannot possibly occur don't count.
>>
>> But what DOES happen when the machine is actual run, do.
>>
>
> On 3/15/2024 3:43 PM, Richard Damon wrote:
> > On 3/15/24 1:37 PM, olcott wrote:
> >>
> >> It is a fact that the behavior of D(D) after it aborts
> >> its simulation cannot be used as abort status criteria or
> >> no H(D,D) would ever abort its simulation.
> >>
> >
> > Yes, that is a correct computational argument, but doesn't prove the
> > criteria used is correct.
> >

Right, DO you not understand what I was saying? Are you THAT Dumb.

The criteria H uses, can ONLY be based on what it actually know.

But to be CORRECT must match with the ACTUAL DETAIL that include what it
doesn't know, including the FULL behavior of the machine when run.

You repeating my statement doesn't disagree with what I just said.

>
>>>
>>>> ALL H's will eventually see that exact same data.
>>>>
>>>>>
>>>>> (c) This entails that the executed H(D,D) sees its abort status
>>>>> criteria
>>>>> sooner than any of its simulated instances.
>>>>
>>>> True. Sooner, but the ALL will when we look at the ACTUAL BEHAVIOR
>>>> of the machine being simulated.
>>>>
>>>
>>> On 3/15/2024 3:43 PM, Richard Damon wrote:
>>>  > On 3/15/24 1:37 PM, olcott wrote:
>>>  >>
>>>  >> It is a fact that the behavior of D(D) after it aborts
>>>  >> its simulation cannot be used as abort status criteria or
>>>  >> no H(D,D) would ever abort its simulation.
>>>  >>
>>>  >
>>>  > Yes, that is a correct computational argument, but doesn't prove the
>>>  > criteria used is correct.
>>>  >
>>
>> Right, H CAN only look at what it has done.
>>
>
> When it has done nothing yet it can't report on this.

So?

It needs to report (to be correct) on what will actually happen.

You seem stuck on that fallacy that an aborted simulation somehow keeps
the machine it was simulating from running.

>
>> TRUTH is based on what WILL Happen (in the actual machines)
>>
> The correct abort criteria cannot do this or H(D,D) never halts.

Right.

That is why H can't be a correct Halt Decider.

You seem to have the mistaken idea that a correct Halt Decider some how
must be possible

Or even that all desired mappings should be computable.

>
>>>
>>>>>
>>>>> (d) We assume (the design criteria) that each H(D,D) aborts its
>>>>> simulation as soon as its abort status criteria has been met.
>>>>
>>>> Ok, but that doesn't prove any given stated conditions are correct.
>>>>
>>> This is a simplifying assumption to make my explanation
>>> less convoluted.
>>
>> But if it isn't a correct criteria, it is just in error.
>>
> The paragraph was much more convoluted when we account for
> every possible fixed number of execution traces rather than
> simply picking the earliest decision point.

But if it doesn't get the right answer, what good is it?

Isn't CORRECTNESS an important part of a specification?

Or is LYING to appear to achieve a goal acceptable to you.

>
>> You are not allowed to ignore the truth just because it is inconvient
>> to you.
>>
> Likewise to you.

I don't, you do.

>
>>>
>>>>>
>>>>> (e) (a)(b)(c)(d) Entail that unless the executed H(D,D) aborts its
>>>>> simulation that none of the simulated instances of H(D,D) ever will.
>>>>>
>>>>
>>>> UNSOUND ARGUMENT. You can't "Assume" that H doesn't abort, since it
>>>> does. You don't understand the logical meaning of "unless"
>>>>
>>>
>>> On 3/15/2024 3:43 PM, Richard Damon wrote:
>>>  > On 3/15/24 1:37 PM, olcott wrote:
>>>  >>
>>>  >> It is a fact that the behavior of D(D) after it aborts
>>>  >> its simulation cannot be used as abort status criteria or
>>>  >> no H(D,D) would ever abort its simulation.
>>>  >>
>>>  >
>>>  > Yes, that is a correct computational argument, but doesn't prove the
>>>  > criteria used is correct.
>>>  >
>>>
>>> <snip you disagreeing with yourself>
>>>
>>
>> Nope.
>>
>> You don't understand.
>>
>> H CAN only determine based on what it has seen.
>>
>
> I do understand that. Even in this post you are trying to say
> that H(D,D) must report on something that it would see rather
> than what it has actually seen.

Right, H, to be correct, must report on what actually is, not guess
(wrongly) based on what it was able to see.

Don't you understand the meaning of CORRECT?

>
>> The CORRECT ANSWER depends on what the actual machine does, even if H
>> hasn't (or even can't) see that behavior.
>>
> You are contradicting yourself.

Nope. WHy do you say that?

CORRECT ANSWER is based on the Truth of what actually happens.

H, can only answer based on what it is able to discover.

If that isn't enough, it might be wrong.

>
>> H, to CORRECTLY determine the results of the correct simulation needs
>> to determine a results that AGREES with that correct simulation.
>>
>
> (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
>
> *H correctly simulates its input D until*
> *requires that the simulation of a non-halting input*
> *must be partial and cannot be complete*
>

Nope. You aren't understanding the words.

The Simulation that H does, will need to be partial, since it must answer.

The Simulation that determines the CORRECT answer might go on forever.

H needs to figure out from the first, if the second is the case.

It needs to use actual correct logic if it is to be correct.

Unfortunately, no such complete set of logic can exist, so H can not be
always correct, and nothing say it has to be unless you make the FALSE
assumption that a correct decider exists.

You don't seem to understand that unsolvable problems exist, and that
doesn't mean the question the problem is trying to solve in invalid in
any way, only that the question is non-computable.

On 3/15/24 3:41 PM, olcott wrote:
> On 3/15/2024 5:10 PM, Richard Damon wrote:
>> On 3/15/24 2:13 PM, olcott wrote:
>>> On 3/15/2024 3:27 PM, Richard Damon wrote:
>>>> On 3/15/24 12:38 PM, olcott wrote:
>>>>> On 3/15/2024 2:30 PM, Richard Damon wrote:
>>>>>> On 3/15/24 12:14 PM, olcott wrote:
>>>>>>> On 3/15/2024 2:06 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 11:39 AM, 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.
>>>>>>>>>
>>>>>>>>
>>>>>>>> But since it does, which is your definition of H, the others
>>>>>>>
>>>>>>> never begin to be simulated.
>>>>>>
>>>>>> But D(D) started to be simulated, and we can know what D(D)
>>>>>> actually does, which includes it using its version of H.
>>>>>>
>>>>>
>>>>> 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).
>>>>>
>>>>
>>>> WHy not?
>>>>
>>>> That is what Correct Simulation refers to.
>>>>
>>>> I guess you are just admiting to being a LIAR (or stupid).
>>>
>>> *I am not a liar or stupid and you admitted your mistake*
>>> *I am not a liar or stupid and you admitted your mistake*
>>> *I am not a liar or stupid and you admitted your mistake*
>>> *I am not a liar or stupid and you admitted your mistake*
>>
>> So, do you admit that the definition of a "Correct Simulation" for the
>> purposes of that criteria are the complete not-aborted simulation done
>> by possibly some other simulator?
>>
>
> (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
>
> Not at all the words don't say anything like that.
> "H correctly simulates its input D until"
> specifically means a partial simulation.
>

On 3/15/2024 6:24 PM, Richard Damon wrote:
> On 3/15/24 3:59 PM, olcott wrote:
>> On 3/15/2024 5:19 PM, Richard Damon wrote:
>>> On 3/15/24 2:26 PM, olcott wrote:
>>>> On 3/15/2024 4:15 PM, Richard Damon wrote:
>>>>> On 3/15/24 2:02 PM, olcott wrote:
>>>>>> On 3/15/2024 3:41 PM, Richard Damon wrote:
>>>>>>> On 3/15/24 1:16 PM, olcott wrote:
>>>>>>>
>>>>>>>> To the best of my current knowledge all of your rebuttals
>>>>>>>> to this relied on counter-factual assumptions that cannot
>>>>>>>> possibly be supported with correct reasoning because they
>>>>>>>> are counter-factual.
>>>>>>>>
>>>>>>>
>>>>>>> Which is a meaningless subjective statement
>>>>>>>
>>>>>>> Since you fail to ever point out an actual couter-factual
>>>>>>> assumption,
>>>>>>
>>>>>>
>>>>>> *I pointed out the facts and you disagreed*
>>>>>> (a) The behavior of every H(D,D) is identical because it is the same
>>>>>> code and data.
>>>>>>
>>>>> Agreed. But that is the FINAL H decided on, since that is the only
>>>>> one that actually exists and D is claimed to be like the H^ in Linz
>>>>> proof
>>>>>
>>>>>> (b) The executed H(D,D) always has at least one execution trace more
>>>>>> data than any of its simulated instances.
>>>>>
>>>>> False. Only true at a given instant of a given H's simulation.
>>>>>
>>>> At each point in any actual execution trace...
>>>> Fantasy traces that cannot possibly occur don't count.
>>>
>>> But what DOES happen when the machine is actual run, do.
>>>
>>
>> On 3/15/2024 3:43 PM, Richard Damon wrote:
>>  > On 3/15/24 1:37 PM, olcott wrote:
>>  >>
>>  >> It is a fact that the behavior of D(D) after it aborts
>>  >> its simulation cannot be used as abort status criteria or
>>  >> no H(D,D) would ever abort its simulation.
>>  >>
>>  >
>>  > Yes, that is a correct computational argument, but doesn't prove the
>>  > criteria used is correct.
>>  >
>
> Right, DO you not understand what I was saying? Are you THAT Dumb.
>
> The criteria H uses, can ONLY be based on what it actually know.
>
As I have been saying for a long time the criteria must be based on what
H actually sees.

> But to be CORRECT must match with the ACTUAL DETAIL that include what it
> doesn't know, including the FULL behavior of the machine when run.
>
(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

*You keep getting this wrong*
*H correctly simulates its input D until*
*requires a partial simulation for all non-terminating inputs*

H cannot correctly report on what it will do before it actually does
this (as you suggest that it must do) or D(D) runs forever.

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

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/15/24 4:31 PM, olcott wrote:
> On 3/15/2024 6:24 PM, Richard Damon wrote:
>> On 3/15/24 3:59 PM, olcott wrote:
>>> On 3/15/2024 5:19 PM, Richard Damon wrote:
>>>> On 3/15/24 2:26 PM, olcott wrote:
>>>>> On 3/15/2024 4:15 PM, Richard Damon wrote:
>>>>>> On 3/15/24 2:02 PM, olcott wrote:
>>>>>>> On 3/15/2024 3:41 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 1:16 PM, olcott wrote:
>>>>>>>>
>>>>>>>>> To the best of my current knowledge all of your rebuttals
>>>>>>>>> to this relied on counter-factual assumptions that cannot
>>>>>>>>> possibly be supported with correct reasoning because they
>>>>>>>>> are counter-factual.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Which is a meaningless subjective statement
>>>>>>>>
>>>>>>>> Since you fail to ever point out an actual couter-factual
>>>>>>>> assumption,
>>>>>>>
>>>>>>>
>>>>>>> *I pointed out the facts and you disagreed*
>>>>>>> (a) The behavior of every H(D,D) is identical because it is the same
>>>>>>> code and data.
>>>>>>>
>>>>>> Agreed. But that is the FINAL H decided on, since that is the only
>>>>>> one that actually exists and D is claimed to be like the H^ in
>>>>>> Linz proof
>>>>>>
>>>>>>> (b) The executed H(D,D) always has at least one execution trace more
>>>>>>> data than any of its simulated instances.
>>>>>>
>>>>>> False. Only true at a given instant of a given H's simulation.
>>>>>>
>>>>> At each point in any actual execution trace...
>>>>> Fantasy traces that cannot possibly occur don't count.
>>>>
>>>> But what DOES happen when the machine is actual run, do.
>>>>
>>>
>>> On 3/15/2024 3:43 PM, Richard Damon wrote:
>>>  > On 3/15/24 1:37 PM, olcott wrote:
>>>  >>
>>>  >> It is a fact that the behavior of D(D) after it aborts
>>>  >> its simulation cannot be used as abort status criteria or
>>>  >> no H(D,D) would ever abort its simulation.
>>>  >>
>>>  >
>>>  > Yes, that is a correct computational argument, but doesn't prove the
>>>  > criteria used is correct.
>>>  >
>>
>> Right, DO you not understand what I was saying? Are you THAT Dumb.
>>
>> The criteria H uses, can ONLY be based on what it actually know.
>>
> As I have been saying for a long time the criteria must be based on what
> H actually sees.

H needs to USE a criteria based on what it sees.

TO be correct, the criteria needs to be correct even about what H
doesn't see.

If that is impossible, the question is not computable.

>
>> But to be CORRECT must match with the ACTUAL DETAIL that include what
>> it doesn't know, including the FULL behavior of the machine when run.
>>
> (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
>
> *You keep getting this wrong*
> *H correctly simulates its input D until*
> *requires a partial simulation for all non-terminating inputs*
>
> H cannot correctly report on what it will do before it actually does
> this (as you suggest that it must do) or D(D) runs forever.
>

But it isn't CORRECT unless the answer it give matches the actual
criteria of the problem, which looks at the full behavior of the program.

You are just admitting that you think it is ok to LIE about what you are
answers so you can give an answer.

That means all the lie tells have an excues for telling their lies,

You are just admitting you don't actually BELIEVE in the concept of truth.

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.

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...

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.

Once we know this we find some encoding of H that prevents this.
The current encoding of H does prevent this.

(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

*H correctly simulates its input D until H*
The above strictly specifies that the simulation of non-halting
inputs must never be complete. *Richard just can't get this*

> 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/15/24 1:25 PM, olcott wrote:
> 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.
>
>> and thus H must be interpreted as such, so the H called by D is a
>> seperate entity to the H deciding on D.
>>
>
> This was not the case with the C functions that I presented to professor
> Sipser.
>
>> Thus, the outer H can not claim it NEEDS to abort, as since the H that
>> is considered to give the correct answer DOES abort,
>
> *You continue to make this same mistake*
> *You continue to make this same mistake*
> *You continue to make this same mistake*
> *You continue to make this same mistake*
>
> 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).

On 3/15/24 2:05 PM, olcott wrote:
> On 3/15/2024 3:43 PM, Richard Damon wrote:
>> On 3/15/24 1:37 PM, olcott wrote:
>>> On 3/15/2024 3:24 PM, Richard Damon wrote:
>>>> On 3/15/24 12:42 PM, olcott wrote:
>>>>> On 3/15/2024 2:27 PM, Richard Damon wrote:
>>>>>> On 3/15/24 12:10 PM, olcott wrote:
>>>>>>> On 3/15/2024 1:59 PM, Richard Damon wrote:
>>>>>>>> On 3/15/24 11:35 AM, 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.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, it doesn't. It sees that your incorrect implementation of
>>>>>>>> that requirement is meet, and thus gives the wrong answer.
>>>>>>>>
>>>>>>>> H1 shows that the correct simuation of the input to D (which is
>>>>>>>> what the criteria you quote looks at) does stop and thus H did
>>>>>>>> not meet its requirements to use step b, but did so anyway.
>>>>>>>>
>>>>>>>> H DECIEVES ITSELF, by imagining it is something it isn't in a
>>>>>>>> way that changes the input to something it isn't and answer,
>>>>>>>> correctly for the wrong question, and thus lies. Just a you do
>>>>>>>> for calling it correct.
>>>>>>>>
>>>>>>>> If the H that you claim is correct does abort, then D uses that
>>>>>>>> H that does that, and thus H's logic is unsound.
>>>>>>>
>>>>>>> It is an easily verified fact that if no H(D,D) aborts its
>>>>>>> simulation that D(D) never halts.
>>>>>>
>>>>>> Right, but EVERY H(D,D) aborts so your condition isn't satified
>>>>>> and your arguement is unsound, just like most of your statments.
>>>>>
>>>>> 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).
>>>>>
>>>>> H(D,D)==0 is correct meaning that the abort criteria has been met.
>>>>>
>>>>
>>>> Why can we not refenerence the behavior of what D(D) does after
>>>> H(D,D) aborts it?
>>>>
>>>
>>> It is a fact that the behavior of D(D) after it aborts
>>> its simulation cannot be used as abort status criteria or
>>> no H(D,D) would ever abort its simulation.
>>>
>>
>> Yes, that is a correct computational argument, but doesn't prove the
>> criteria used is correct.
>>
> Finally a breakthrough.

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.

>
> 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
saying non-halting as it now is looking at a TOTALLY new set of input.

You don't seem very "Exhaustive" in your reasoning.

>
> Once we know this we find some encoding of H that prevents this.
> The current encoding of H does prevent this.

Why?

What shows that there exists such an H?

That is your false assumption.

>
> (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
>
> *H correctly simulates its input D until H*
> The above strictly specifies that the simulation of non-halting
> inputs must never be complete. *Richard just can't get this*

Right, but since you changed the H to aborting, now the H^'s it is
looking at ALSO abort, and thus return from their H^.H, which H doesn't
ever see.

Since now the correct simulation of the input does Halt (since H aborts
and returns non-halting) H, for THESE inputs, never correctly determined
that the simulatio is non-halting.

H is just LYING to itself that the H it sees was the old H that didn't
abort.

Lying to yourself is a good way to get the wrong answers.

>
>> 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/15/24 11:05 AM, olcott wrote:
> On 3/15/2024 11: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).
>>
>>
>
> On 3/15/2024 12:44 PM, Richard Damon wrote:
> > On 3/15/24 10:11 AM, olcott wrote:
> >> D(D) specifies an infinite chain of H(D,D) unless D(D) is
> >> aborted at some point. The outermost H(D,D) always has
> >> seen a longer execution trace than any of the inner ones.
> >>
> >
> > Right, *AT SOME POINT* but not nessesarily HERE.
> >
> > No, the outermose has seen more execution trace then
> > the innerones have at the point that H aborts their
> > simulation.
> >
>
> (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 seems like you are agreeing with me that H(D,D)==0
> is correct for the above criteria.
>

Nope.

It may be the best it can do, but since D(D) halts, then the CORRECT
SIMULATION of D(D) will reach and end, so H can not have correctly
determined that it will not halt, and thus H has no actual ground to
declaire its answer is correct.

And, since D(D) Halts, we see that the ACTUAL correct answer is 1.

H is forced to decide what to do before it can possible see the copy of
itself making its decision, and thus it is in a pickle.

And thus, H just gets the wrong answer.

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.

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

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.

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