On 3/17/2024 12:37 PM, immibis wrote:
> On 17/03/24 14:11, olcott wrote:
>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>> On 3/16/24 10:04 PM, olcott wrote:
>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable requirement.
>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But turning out to be impposible, doesn't make it incorrect
>>>>>>>>>>>>> or invalid.
>>>>>>>>>>>>
>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls
>>>>>>>>>>>> H(D,D) either H(D,D) aborts its simulation or D(D) never
>>>>>>>>>>>> stops running.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>> what you need it to.
>>>>>>>>>>>
>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>
>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>
>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope.
>>>>>>>>
>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>> That is all that this thread's H does.
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>> And what defines "Need"?
>>>>>>>
>>>>>> It is the set of every implementation of its spec:
>>>>>> (a) H(D,D) Simulate input.
>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>> the simulated D(D) from never halting.
>>>>>>
>>>>>
>>>>> And thus not a specific algorithm?
>>>>>
>>>>> Again, HOW do you determine NEED?
>>>>>
>>>>> That is not an algorithmic step.
>>>>>
>>>>> We can only verify that in retrospect.
>>>>
>>>> Do you fully understand the spec?
>>>>
>>>>
>>>
>>> Yes, but I think not the way you do.
>>>
>>> To me, for H to NEED to abort its simulation, that means that when
>>> giving the input to a correct simulator, that simulator will not halt.
>>>
>> Yes that is correct.
>
> You have just proven that H doesn't need abort its simulation and the
> abort decision is incorrect.

The head games of a Troll.

For every possible way that H can be encoded and D(D)
calls H(D,D) either H(D,D) aborts its simulation or D(D)
never stops running.

--
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/17/2024 11:34 AM, Richard Damon wrote:
> On 3/17/24 6:39 AM, olcott wrote:
>> On 3/17/2024 8:33 AM, Mikko wrote:
>>> On 2024-03-16 14:49:31 +0000, olcott said:
>>>
>>>> On 3/16/2024 3:51 AM, Mikko wrote:
>>>>> On 2024-03-15 18:38:23 +0000, immibis said:
>>>>>
>>>>>> 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?
>>>>>
>>>>> Counting to two is not as trivial as some people think.
>>>>>
>>>>
>>>> There cannot possibly exist any H(D,D) that is called by
>>>> D where H(D,D) simulates its input and D(D) stops running
>>>> and H never aborts its simulation.
>>>
>>> However there is a H' not called by D where H'(D,D) simulates
>>> its input and D(D) stops running and H' never aborts its simulation.
>>>
>>
>> That exists as H1(D,D) yet only works because H(D,D) aborts its
>> simulation.
>>
>
> But not the individual H that is giving the answer, but another
> identical copy of it.
>
> This H can't claim credit for wht the other H did.
>
> Especially since that other H doesn't have the same representation as
> this one (its state 0 is different).
>
> Remember, every copy of a Turing Machine is its own independent machine,

You seem to be diverging off topic:
[Proof that H(D,D) meets its abort criteria]

--
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/17/2024 2:45 PM, Richard Damon wrote:
> On 3/17/24 9:31 AM, olcott wrote:
>> On 3/17/2024 11:13 AM, Mikko wrote:
>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>
>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>
>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>
>>>>>>>> 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).
>>>>>>>
>>>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>>>> the same.
>>>>>>>
>>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>> what it meets instead.
>>>>>>>
>>>>>>
>>>>>> The original halt status criteria has the impossible requirement
>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>
>>>>> The requirement is not specifically about behaviour that the decider
>>>>> does not actually see but requires reporting anyway, whether the
>>>>> decider sees or not. So it turns out that it is not possible to
>>>>> meet the specification in all cases.
>>>>>
>>>> I think that the decider can meet its abort criteria in all cases.
>>>
>>> But cannot meet its specification.
>>>
>>
>> First we must come to mutual agreement that H(D,D) is correct
>> to abort its simulation.
>
> Which means we need to first come to an aggreement of what that means.
>
> You DID agree earlier to this:
>
> On 3/17/24 6:11 AM, olcott wrote:
> > On 3/17/2024 12:22 AM, Richard Damon wrote:
> >> To me, for H to NEED to abort its simulation, that means that when
> >> giving the input to a correct simulator, that simulator will not halt.
> >>
> > Yes that is correct.
> >
>

For every possible way that H can be encoded and D(D)
calls H(D,D) either H(D,D) aborts its simulation or D(D)
never stops running.

It will not halt unless it aborts its simulation.

> So, by THAT criteria, H(D,D) is only correct to abort it simulation if
> UTM(D,D) fails to Halt,

Not at all. H(D,D) aborts its simulation when not aborting
its simulation would cause H(D,D) itself to never halt.

--
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/17/2024 2:39 PM, Richard Damon wrote:
> On 3/17/24 6:52 AM, olcott wrote:
>> On 3/17/2024 8:46 AM, Mikko wrote:
>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>
>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>
>>>>>> 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).
>>>>>
>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>> the same.
>>>>>
>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>> not meet the specification of halting decider it does not matter
>>>>> what it meets instead.
>>>>>
>>>>
>>>> The original halt status criteria has the impossible requirement
>>>> that H(D,D) must report on behavior that it does not actually see.
>>>
>>> The requirement is not specifically about behaviour that the decider
>>> does not actually see but requires reporting anyway, whether the
>>> decider sees or not. So it turns out that it is not possible to
>>> meet the specification in all cases.
>>>
>> I think that the decider can meet its abort criteria in all cases.
>
> Then show HOW.
>
> "I think" is not proof, especially from you.
>

The non-existence of counter-examples is proof.

--
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/17/2024 2:36 PM, Richard Damon wrote:
> On 3/17/24 10:35 AM, immibis wrote:
>> On 17/03/24 17:47, olcott wrote:
>>> It is an empirically verified fact that either
>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>>> running (not counting stack overflow).
>>
>> Sipser_H and Sipser_D are the same code that you called H and D in
>> x86utm, right?
>
> No, Sipser_D returns 0 instead of looping, and Sipser_H is supposed to
> return what Sipser_D does, or 0 if it is non-halting.
>
> Of course, in Sipser's paper his D doesn't take a parameter, but
> Olcott's Sipser_D does, likely because his H needs two paramaters and
> always calls the input program with one.
>

*Rebutting the Sipser Halting Problem Proof*
10/10/22 11:36:14 AM version
https://philarchive.org/archive/OLCRTSv1

My C code seems to exactly model his TM code and actually does
put the correct value in the ? of the table on the last page.

My table is identical to his.
https://www.liarparadox.org/Sipser_165_167.pdf

> His Sipser_H is likely the same, or almost the same (won't check if he
> fixed the halting state to return what the simulated input does, since
> that doesn't actually ever come into play for this arguement).
>
>>
>> It is an empirically verified fact that H(D,D) aborts its simulation.
>>
>> True or anything is still true.
>>
>> It is an empirically verified fact that either H(D,D) aborts its
>> simulation or the sky is purple.
>>
>> It is an empirically verified fact that either H(D,D) aborts its
>> simulation or the current time is yes.
>>
>
> Yep, He doesn't seem to understand that if his decider abort its
> simulation, he can't argure about it also NOT doing that, and what
> happens then.

--
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/17/2024 2:02 PM, Richard Damon wrote:
> On 3/17/24 9:35 AM, olcott wrote:
>> On 3/17/2024 11:09 AM, Mikko wrote:
>>> On 2024-03-17 13:53:03 +0000, olcott said:
>>>
>>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>>
>>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by
>>>>>>>>>>>>>>>>>> sipser*
>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim
>>>>>>>>>>>>>>>>>> paragraph is correct*
>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else
>>>>>>>>>>>>>>>>>> in this paper)
>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates
>>>>>>>>>>>>>>>>>> its input D until H correctly determines that its
>>>>>>>>>>>>>>>>>> simulated D would never stop running unless aborted then
>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly
>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ;
>>>>>>>>>>>>>>>>>> begin main()
>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call
>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ;
>>>>>>>>>>>>>>>>>> enter D(D)
>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov
>>>>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ;
>>>>>>>>>>>>>>>>>> push D
>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov
>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ;
>>>>>>>>>>>>>>>>>> push D
>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call
>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being
>>>>>>>>>>>>>>>>>> called with its same inputs and there are no
>>>>>>>>>>>>>>>>>> conditional branch instructions between the invocation
>>>>>>>>>>>>>>>>>> of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the
>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop running
>>>>>>>>>>>>>>>>> because *ITS* H will abort *ITS* simulation and returm
>>>>>>>>>>>>>>>>> 0 so that simulated D will halt.
>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then
>>>>>>>>>>>>>>> when it's convenient for you you think there is only one
>>>>>>>>>>>>>>> H(D,D). Why is that?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>
>>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>>> investigated this.
>>>>>>>>>>>> Because every H has the exact same code, if the first one to
>>>>>>>>>>>> see that
>>>>>>>>>>>> the abort criteria has been met does not abort then none of
>>>>>>>>>>>> them abort.
>>>>>>>>>>>
>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H
>>>>>>>>>>> that we started with.
>>>>>>>>>>>
>>>>>>>>>>> If you change the H used by D, you change the quesition being
>>>>>>>>>>> asked.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>> for this H(D,D).
>>>>>>>>>
>>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>>> you need to reference in the proof.
>>>>>>>>>
>>>>>>>>
>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>
>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>> and H never aborts its simulation.
>>>>>>>
>>>>>>> The set from wich such H could be chosen is so small that
>>>>>>> it is no surprise that any H that simulates D(D) to its
>>>>>>> termination is not in that set.
>>>>>>>
>>>>>>
>>>>>> As soon as we hit complete proof of this we can move on
>>>>>> to another point.
>>>>>
>>>>> A complete proof of what?
>>>>>
>>>> [Proof that H(D,D) meets its abort criteria]
>>>
>>> It is possible that you don't find such proof.
>>>
>>
>> Been there done that many times. That no one has understood
>> this is no actual rebuttal what-so-ever. We must achieve
>> mutual agreement on this at least for H(D,D) before we move
>> on to the next point or no points will ever get any closure.
>>
>
> In other words, you inability to actually proves your statement isn't a
> proof that you haven't proved your claims?
>

On 3/17/2024 12:50 PM, Richard Damon wrote:
> On 3/17/24 9:47 AM, olcott wrote:
>> On 3/17/2024 11:00 AM, Richard Damon wrote:
>>> On 3/17/24 6:11 AM, olcott wrote:
>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>
>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>> And what defines "Need"?
>>>>>>>>>
>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>
>>>>>>>
>>>>>>> And thus not a specific algorithm?
>>>>>>>
>>>>>>> Again, HOW do you determine NEED?
>>>>>>>
>>>>>>> That is not an algorithmic step.
>>>>>>>
>>>>>>> We can only verify that in retrospect.
>>>>>>
>>>>>> Do you fully understand the spec?
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but I think not the way you do.
>>>>>
>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>
>>>> Yes that is correct.
>>>
>>> And THIS input (that used the H that aborts), when given to a correct
>>> simulator, will reach an end.
>>>
>>> Since you just agreed to my definition, you agree that this H didn't
>>> need to abort.
>>>
>>>>
>>>>> I say this isn't the way you do, as I have shown that H fails to
>>>>> meet this specification.
>>>>>
>>>> (a) If abort halt decider H correctly simulates its input D until H
>>>> correctly determines that its simulated D would never stop running
>>>> unless aborted then
>>>>
>>>> This is the way that I do it and you have never shown otherwise.
>>>
>>> Nope, you use an H that aborts because it non-aborting brother needed
>>> to abort the brother of your input
>>>
>>>>
>>>>> You can't seem to actually define it the way you want, likely
>>>>> because you don't actually understand what you are doing.
>>>>>
>>>> It seems to me that the issue is your persistence in remaining in
>>>> rebuttal mode even when this contradicts the verified facts.
>>>
>>> No, you are stuck it trying to call two things that are different as
>>> if they were the same.
>>>
>>>>
>>>>> This seems clear as your "implementation" isn't actually an
>>>>> implementation as it includes non-algorithmic steps.
>>>>>
>>>> My C code provably does do this and I can show a TM equivalent.
>>>
>>> Nope.
>>>
>>> DO IT if you can.
>>>
>>>>
>>>>> There is no "Get the right answer" instruction, or look into the
>>>>> future (or even look into an alternate future) instruction.
>>>>
>>>>   machine   stack     stack     machine    assembly
>>>>   address   address   data      code       language
>>>>   ========  ========  ========  =========  =============
>>>> [00001d22][00102fc9][00000000] 55         push ebp
>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>> [00001d25][00102fc5][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
>>>> [00001d2a][00102fc1][00001b32] 68321b0000 push 00001b32 ; push Sipser_D
>>>> [00001d2f][00102fbd][00001d34] e8eef8ffff call 00001622 ; call Sipser_H
>>>>
>>>> Sipser_H: Begin Simulation   Execution Trace Stored at:113075
>>>> Address_of_Sipser_H:1622
>>>> [00001b32][00113061][00113065] 55         push ebp
>>>> [00001b33][00113061][00113065] 8bec       mov ebp,esp
>>>> [00001b35][00113061][00113065] 8b4508     mov eax,[ebp+08]
>>>> [00001b38][0011305d][00001b32] 50         push eax      ; push Sipser_D
>>>> [00001b39][0011305d][00001b32] 8b4d08     mov ecx,[ebp+08]
>>>> [00001b3c][00113059][00001b32] 51         push ecx      ; push Sipser_D
>>>> [00001b3d][00113055][00001b42] e8e0faffff call 00001622 ; call Sipser_H
>>>> Sipser_H: Recursive Simulation Detected Simulation Stopped
>>>
>>> And that is becase your Sipser_H deterined that Sipser_H won't halt
>>> unless aborted, not Sipser_D.
>>>
>>> Sipser_D will ALWAYS halt if Sipser_H returns a value, as it is
>>> required.
>>>
>>>>
>>>> [00001d34][00102fc9][00000000] 83c408     add esp,+08
>>>> [00001d37][00102fc5][00000000] 50         push eax
>>>> [00001d38][00102fc1][00000743] 6843070000 push 00000743
>>>> [00001d3d][00102fc1][00000743] e820eaffff call 00000762
>>>> Input_Halts = 0
>>>> [00001d42][00102fc9][00000000] 83c408     add esp,+08
>>>> [00001d45][00102fc9][00000000] 33c0       xor eax,eax
>>>> [00001d47][00102fcd][00000018] 5d         pop ebp
>>>> [00001d48][00102fd1][00000000] c3         ret
>>>> Number of Instructions Executed(868) == 13 Pages
>>>>
>>>> We can see that Sipser_D(Sipser_D) cannot stop running unless
>>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation.
>>>>
>>>
>>> No, it shows that a Sipser_H that doesn't figure out when to abort
>>> its simulations will fail to meet its requirements.
>>>
>>> Since your Sipser_H DOES abort (as your trace shows the outer one
>>> does) it needs to figure out what Sipser_D will do with its answers,
>>> but it can't just use "brute-force" simulation.
>>>
>>
>> It is an empirically verified fact that either
>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>> running (not counting stack overflow).
>>
>> Your pathological thinking incorrectly denies this
>> empirically verified fact.
>
> Whch isn't the question
>
> IF Sipser_H(x, y) doesn't return, it is wrong.
>
> Thus If Sipser_D calls Sipser_H(Sipser_D, Sipser_D) and it doesn't
> return, Sipser_H was wrong.
>
> If it does return, then Sipser_D will return,
>
> Thus, any case where Sipser_H didn't return, it was wrong.
>
> Thus Sipser_H needing to abort, it just part of the algoithm of Sipser_H.
>
> Also, you AGREED that the definition of "Need to Abort" is if the input
> was given to a correct pure simulator, and that halted, there was no
> "Need to Abort".
>
> Thus, since we KNOW,since you claim Sipser_H meets its requirements, and
> you CAN'T be wrong ;), that Sipser_D will thus always return so that
> simulation will always halt, So, your Sipser_H may have aborted as you
> found out you needed to do that if you didn't do it, but once you do it
> you don't need to do it.
>
>
>
> Second Point, showing how you don't read the paper you quote.
>
> The D from the Sipser paper, doesn't take any arguments, and the H from
> that paper takes just one argument, that of the argument machine it is
> deciding on.
>
> This make the logic to analyise it simpler, as  Ds behavior is just a
> constant, and thus clearly isn't being too "tricky". Since H MUST return
> a value or be proved wrong, inspection of D is obviously halting, and
> thus no arguements about non-halting behavior need get involved. Any
> non-halting behavior disqualifies tha H.
>
> You are just somehow mixing Turings H / H^ with Sipser H / D (which are
> slightly different as just described) to get your Frankestein combo that
> is neither.
>

On 18/03/24 00:27, olcott wrote:
> On 3/17/2024 12:37 PM, immibis wrote:
>> On 17/03/24 14:11, olcott wrote:
>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls
>>>>>>>>>>>>> H(D,D) either H(D,D) aborts its simulation or D(D) never
>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>
>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>
>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope.
>>>>>>>>>
>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>> And what defines "Need"?
>>>>>>>>
>>>>>>> It is the set of every implementation of its spec:
>>>>>>> (a) H(D,D) Simulate input.
>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>> the simulated D(D) from never halting.
>>>>>>>
>>>>>>
>>>>>> And thus not a specific algorithm?
>>>>>>
>>>>>> Again, HOW do you determine NEED?
>>>>>>
>>>>>> That is not an algorithmic step.
>>>>>>
>>>>>> We can only verify that in retrospect.
>>>>>
>>>>> Do you fully understand the spec?
>>>>>
>>>>>
>>>>
>>>> Yes, but I think not the way you do.
>>>>
>>>> To me, for H to NEED to abort its simulation, that means that when
>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>
>>> Yes that is correct.
>>
>> You have just proven that H doesn't need abort its simulation and the
>> abort decision is incorrect.
>
> The head games of a Troll.
>
> For every possible way that H can be encoded and D(D)
> calls H(D,D) either H(D,D) aborts its simulation or D(D)
> never stops running.
>

Wrong.

On 18/03/24 00:24, olcott wrote:
> On 3/17/2024 12:35 PM, immibis wrote:
>> On 17/03/24 17:47, olcott wrote:
>>> It is an empirically verified fact that either
>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>>> running (not counting stack overflow).
>>
>> Sipser_H and Sipser_D are the same code that you called H and D in
>> x86utm, right?
>>
> Not quite.
> int Sipser_D(int (*M)())
> {
>   if ( Sipser_H(M, M) )
>     return 0;
>   return 1;
> }
>
> Sipser_H is the same and Sipser_H(Sipser_D, Sipser_D)
> is isomorphic to H(D,D)
>
>> It is an empirically verified fact that H(D,D) aborts its simulation.
> That is not the question.
>
> We are verifying that it is proven to be correct.
> [Proof that H(D,D) meets its abort criteria --self-evident truth--]

=== DEFINITION OF CORRECT ===

Output Q of a halt decider H(X,Y) is correct if and only if:
1. Q==1 and X(Y) halts, or
2. Q==0 and X(Y) does not halt

=== CONCLUSION ===
it is incorrect

>
> For every possible way that H can be encoded and D(D)
> calls H(D,D) either H(D,D) aborts its simulation or D(D)
> never stops running.
>
>

On 3/17/24 5:04 PM, olcott wrote:
>
> *THIS IS BY ITSELF COMPLETE PROOF THAT H(D,D) MUST ABORT ITS SIMULATION*
> For every possible way that H can be encoded and D(D)
> calls H(D,D) either H(D,D) aborts its simulation or D(D)
> never stops running.
>

Nope, and that statements proves that you are just and ignorant liar
that doesn't knwo what truth is or what is a proof.

Remember, the input is built on a copy of the decider, so each different
decider has a different input and thus the behavior of the input made
from the deciders that don't abort will be different than the behavior
of the input made for deciders that DO abort their simulation.

As you agreed here:

On 3/17/24 6:11 AM, olcott wrote:
> On 3/17/2024 12:22 AM, Richard Damon wrote:
>> To me, for H to NEED to abort its simulation, that means that when
>> giving the input to a correct simulator, that simulator will not halt.
>>
> Yes that is correct.
>

The test for "Needs to Abort" is what a complete correct simulation does
with this input.

Since, if H(D,D) aborts its simulation and returns 0, then that D will
use that same H, and get the 0 return, and then halts, and thus the
complete simulation of this input will halt, and thus, BY THE DEFINITION
YOU AGREED TO, H(D,D) did not "Need" to abort its simulation.

You have yet to be able to come up with an actual "reasonable" alternate
definition of this that does require looking at an input that isn't
actually the input to the H that claims to have the need, and thus aborts.

You are just proving you believe LYING as a VALID form of argument.

On 3/17/24 5:02 PM, olcott wrote:
> On 3/17/2024 2:36 PM, Richard Damon wrote:
>> On 3/17/24 10:35 AM, immibis wrote:
>>> On 17/03/24 17:47, olcott wrote:
>>>> It is an empirically verified fact that either
>>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>>>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>>>> running (not counting stack overflow).
>>>
>>> Sipser_H and Sipser_D are the same code that you called H and D in
>>> x86utm, right?
>>
>> No, Sipser_D returns 0 instead of looping, and Sipser_H is supposed to
>> return what Sipser_D does, or 0 if it is non-halting.
>>
>> Of course, in Sipser's paper his D doesn't take a parameter, but
>> Olcott's Sipser_D does, likely because his H needs two paramaters and
>> always calls the input program with one.
>>
>
> *Rebutting the Sipser Halting Problem Proof*
> 10/10/22 11:36:14 AM  version
> https://philarchive.org/archive/OLCRTSv1
>
> My C code seems to exactly model his TM code and actually does
> put the correct value in the ? of the table on the last page.

Nope.

And what is the value you put in there?

If H says that D will accept <D>, then D will see that same answer and
reject it.

If H says that D will reject <D>, then D will see that same answer and
accept it.

This D is NEVER non-halting if H answers, and thus H never needs to, or
can correctly claim, the input is non-halting unless H is (and thus H
admits it fails),

Your claim is that H can correct say that D won't answer unless H aborts
its simulation, but that ISN'T the criteria. H needs to answer whatever
D answer, if D will answer.

Since this input D will ALWAYS answer if H answers, H claiming the input
doesn't answer is either a LIE, or an admission that H itself doesn't
answer for this input, and thus isn't actually a correct decider.

You are just showing that you don't understand what you are talking about.

>
> My table is identical to his.
> https://www.liarparadox.org/Sipser_165_167.pdf
>
>> His Sipser_H is likely the same, or almost the same (won't check if he
>> fixed the halting state to return what the simulated input does, since
>> that doesn't actually ever come into play for this arguement).
>>
>>>
>>> It is an empirically verified fact that H(D,D) aborts its simulation.
>>>
>>> True or anything is still true.
>>>
>>> It is an empirically verified fact that either H(D,D) aborts its
>>> simulation or the sky is purple.
>>>
>>> It is an empirically verified fact that either H(D,D) aborts its
>>> simulation or the current time is yes.
>>>
>>
>> Yep, He doesn't seem to understand that if his decider abort its
>> simulation, he can't argure about it also NOT doing that, and what
>> happens then.
>

On 3/17/24 5:12 PM, olcott wrote:
> On 3/17/2024 12:50 PM, Richard Damon wrote:
>> On 3/17/24 9:47 AM, olcott wrote:
>>> On 3/17/2024 11:00 AM, Richard Damon wrote:
>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>
>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>
>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus not a specific algorithm?
>>>>>>>>
>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>
>>>>>>>> That is not an algorithmic step.
>>>>>>>>
>>>>>>>> We can only verify that in retrospect.
>>>>>>>
>>>>>>> Do you fully understand the spec?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but I think not the way you do.
>>>>>>
>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>> halt.
>>>>>>
>>>>> Yes that is correct.
>>>>
>>>> And THIS input (that used the H that aborts), when given to a
>>>> correct simulator, will reach an end.
>>>>
>>>> Since you just agreed to my definition, you agree that this H didn't
>>>> need to abort.
>>>>
>>>>>
>>>>>> I say this isn't the way you do, as I have shown that H fails to
>>>>>> meet this specification.
>>>>>>
>>>>> (a) If abort halt decider H correctly simulates its input D until H
>>>>> correctly determines that its simulated D would never stop running
>>>>> unless aborted then
>>>>>
>>>>> This is the way that I do it and you have never shown otherwise.
>>>>
>>>> Nope, you use an H that aborts because it non-aborting brother
>>>> needed to abort the brother of your input
>>>>
>>>>>
>>>>>> You can't seem to actually define it the way you want, likely
>>>>>> because you don't actually understand what you are doing.
>>>>>>
>>>>> It seems to me that the issue is your persistence in remaining in
>>>>> rebuttal mode even when this contradicts the verified facts.
>>>>
>>>> No, you are stuck it trying to call two things that are different as
>>>> if they were the same.
>>>>
>>>>>
>>>>>> This seems clear as your "implementation" isn't actually an
>>>>>> implementation as it includes non-algorithmic steps.
>>>>>>
>>>>> My C code provably does do this and I can show a TM equivalent.
>>>>
>>>> Nope.
>>>>
>>>> DO IT if you can.
>>>>
>>>>>
>>>>>> There is no "Get the right answer" instruction, or look into the
>>>>>> future (or even look into an alternate future) instruction.
>>>>>
>>>>>   machine   stack     stack     machine    assembly
>>>>>   address   address   data      code       language
>>>>>   ========  ========  ========  =========  =============
>>>>> [00001d22][00102fc9][00000000] 55         push ebp
>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>> [00001d25][00102fc5][00001b32] 68321b0000 push 00001b32 ; push
>>>>> Sipser_D
>>>>> [00001d2a][00102fc1][00001b32] 68321b0000 push 00001b32 ; push
>>>>> Sipser_D
>>>>> [00001d2f][00102fbd][00001d34] e8eef8ffff call 00001622 ; call
>>>>> Sipser_H
>>>>>
>>>>> Sipser_H: Begin Simulation   Execution Trace Stored at:113075
>>>>> Address_of_Sipser_H:1622
>>>>> [00001b32][00113061][00113065] 55         push ebp
>>>>> [00001b33][00113061][00113065] 8bec       mov ebp,esp
>>>>> [00001b35][00113061][00113065] 8b4508     mov eax,[ebp+08]
>>>>> [00001b38][0011305d][00001b32] 50         push eax      ; push
>>>>> Sipser_D
>>>>> [00001b39][0011305d][00001b32] 8b4d08     mov ecx,[ebp+08]
>>>>> [00001b3c][00113059][00001b32] 51         push ecx      ; push
>>>>> Sipser_D
>>>>> [00001b3d][00113055][00001b42] e8e0faffff call 00001622 ; call
>>>>> Sipser_H
>>>>> Sipser_H: Recursive Simulation Detected Simulation Stopped
>>>>
>>>> And that is becase your Sipser_H deterined that Sipser_H won't halt
>>>> unless aborted, not Sipser_D.
>>>>
>>>> Sipser_D will ALWAYS halt if Sipser_H returns a value, as it is
>>>> required.
>>>>
>>>>>
>>>>> [00001d34][00102fc9][00000000] 83c408     add esp,+08
>>>>> [00001d37][00102fc5][00000000] 50         push eax
>>>>> [00001d38][00102fc1][00000743] 6843070000 push 00000743
>>>>> [00001d3d][00102fc1][00000743] e820eaffff call 00000762
>>>>> Input_Halts = 0
>>>>> [00001d42][00102fc9][00000000] 83c408     add esp,+08
>>>>> [00001d45][00102fc9][00000000] 33c0       xor eax,eax
>>>>> [00001d47][00102fcd][00000018] 5d         pop ebp
>>>>> [00001d48][00102fd1][00000000] c3         ret
>>>>> Number of Instructions Executed(868) == 13 Pages
>>>>>
>>>>> We can see that Sipser_D(Sipser_D) cannot stop running unless
>>>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation.
>>>>>
>>>>
>>>> No, it shows that a Sipser_H that doesn't figure out when to abort
>>>> its simulations will fail to meet its requirements.
>>>>
>>>> Since your Sipser_H DOES abort (as your trace shows the outer one
>>>> does) it needs to figure out what Sipser_D will do with its answers,
>>>> but it can't just use "brute-force" simulation.
>>>>
>>>
>>> It is an empirically verified fact that either
>>> Sipser_H(Sipser_D, Sipser_D) aborts its simulation or neither
>>> Sipser_H(Sipser_D, Sipser_D) nor Sipser_D(Sipser_D) ever stops
>>> running (not counting stack overflow).
>>>
>>> Your pathological thinking incorrectly denies this
>>> empirically verified fact.
>>
>> Whch isn't the question
>>
>> IF Sipser_H(x, y) doesn't return, it is wrong.
>>
>> Thus If Sipser_D calls Sipser_H(Sipser_D, Sipser_D) and it doesn't
>> return, Sipser_H was wrong.
>>
>> If it does return, then Sipser_D will return,
>>
>> Thus, any case where Sipser_H didn't return, it was wrong.
>>
>> Thus Sipser_H needing to abort, it just part of the algoithm of Sipser_H.
>>
>> Also, you AGREED that the definition of "Need to Abort" is if the
>> input was given to a correct pure simulator, and that halted, there
>> was no "Need to Abort".
>>
>> Thus, since we KNOW,since you claim Sipser_H meets its requirements,
>> and you CAN'T be wrong ;), that Sipser_D will thus always return so
>> that simulation will always halt, So, your Sipser_H may have aborted
>> as you found out you needed to do that if you didn't do it, but once
>> you do it you don't need to do it.
>>
>>
>>
>> Second Point, showing how you don't read the paper you quote.
>>
>> The D from the Sipser paper, doesn't take any arguments, and the H
>> from that paper takes just one argument, that of the argument machine
>> it is deciding on.
>>
>> This make the logic to analyise it simpler, as  Ds behavior is just a
>> constant, and thus clearly isn't being too "tricky". Since H MUST
>> return a value or be proved wrong, inspection of D is obviously
>> halting, and thus no arguements about non-halting behavior need get
>> involved. Any non-halting behavior disqualifies tha H.
>>
>> You are just somehow mixing Turings H / H^ with Sipser H / D (which
>> are slightly different as just described) to get your Frankestein
>> combo that is neither.
>>
>
> Both the original and current version get the correct answer
> to Professor Sipser's (last row/col) Figure 4.6 question.
>
> *Rebutting the Sipser Halting Problem Proof*
> https://philarchive.org/archive/OLCRTSv1  10/10/22 11:36:14 AM
> https://philpapers.org/archive/OLCRTS.pdf 10/16/23 09:56:55 AM
>

On 3/17/24 4:27 PM, olcott wrote:
> On 3/17/2024 12:37 PM, immibis wrote:
>> On 17/03/24 14:11, olcott wrote:
>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls
>>>>>>>>>>>>> H(D,D) either H(D,D) aborts its simulation or D(D) never
>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>
>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>
>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>
>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Nope.
>>>>>>>>>
>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>
>>>>>>>> And what defines "Need"?
>>>>>>>>
>>>>>>> It is the set of every implementation of its spec:
>>>>>>> (a) H(D,D) Simulate input.
>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>> the simulated D(D) from never halting.
>>>>>>>
>>>>>>
>>>>>> And thus not a specific algorithm?
>>>>>>
>>>>>> Again, HOW do you determine NEED?
>>>>>>
>>>>>> That is not an algorithmic step.
>>>>>>
>>>>>> We can only verify that in retrospect.
>>>>>
>>>>> Do you fully understand the spec?
>>>>>
>>>>>
>>>>
>>>> Yes, but I think not the way you do.
>>>>
>>>> To me, for H to NEED to abort its simulation, that means that when
>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>
>>> Yes that is correct.
>>
>> You have just proven that H doesn't need abort its simulation and the
>> abort decision is incorrect.
>
> The head games of a Troll.
>
> For every possible way that H can be encoded and D(D)
> calls H(D,D) either H(D,D) aborts its simulation or D(D)
> never stops running.
>

Which prove NOTHING, as D varies with H, so no D that was built with an
H that aborts its simulation has had its actual halting status tested.

You are just proving you are using unsound logic.

You even agreed that the test of "Needs" was to give the input to an
actual correct decider (which doesn't abort) and if it halts, then H was
wrong, but that simulation will halt so H wasn't correct to abort.

So, you are showing that you are just lying.

On 3/17/24 4:28 PM, olcott wrote:
> On 3/17/2024 11:34 AM, Richard Damon wrote:
>> On 3/17/24 6:39 AM, olcott wrote:
>>> On 3/17/2024 8:33 AM, Mikko wrote:
>>>> On 2024-03-16 14:49:31 +0000, olcott said:
>>>>
>>>>> On 3/16/2024 3:51 AM, Mikko wrote:
>>>>>> On 2024-03-15 18:38:23 +0000, immibis said:
>>>>>>
>>>>>>> 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?
>>>>>>
>>>>>> Counting to two is not as trivial as some people think.
>>>>>>
>>>>>
>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>> and H never aborts its simulation.
>>>>
>>>> However there is a H' not called by D where H'(D,D) simulates
>>>> its input and D(D) stops running and H' never aborts its simulation.
>>>>
>>>
>>> That exists as H1(D,D) yet only works because H(D,D) aborts its
>>> simulation.
>>>
>>
>> But not the individual H that is giving the answer, but another
>> identical copy of it.
>>
>> This H can't claim credit for wht the other H did.
>>
>> Especially since that other H doesn't have the same representation as
>> this one (its state 0 is different).
>>
>> Remember, every copy of a Turing Machine is its own independent machine,
>
> You seem to be diverging off topic:
> [Proof that H(D,D) meets its abort criteria]
>

Not really, since you still claim you will prove this H to be isomorphic
to the Linz machine H.

That influences the meaning of the words.

On 3/17/24 4:47 PM, olcott wrote:
> On 3/17/2024 2:45 PM, Richard Damon wrote:
>> On 3/17/24 9:31 AM, olcott wrote:
>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>
>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>
>>>>>>>>> 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).
>>>>>>>>
>>>>>>>> This proof is not simpler or more convinceing than earlier
>>>>>>>> proofs of
>>>>>>>> the same.
>>>>>>>>
>>>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>>> what it meets instead.
>>>>>>>>
>>>>>>>
>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>
>>>>>> The requirement is not specifically about behaviour that the decider
>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>> meet the specification in all cases.
>>>>>>
>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>
>>>> But cannot meet its specification.
>>>>
>>>
>>> First we must come to mutual agreement that H(D,D) is correct
>>> to abort its simulation.
>>
>> Which means we need to first come to an aggreement of what that means.
>>
>> You DID agree earlier to this:
>>
>> On 3/17/24 6:11 AM, olcott wrote:
>>  > On 3/17/2024 12:22 AM, Richard Damon wrote:
>>  >> To me, for H to NEED to abort its simulation, that means that when
>>  >> giving the input to a correct simulator, that simulator will not
>> halt.
>>  >>
>>  > Yes that is correct.
>>  >
>>
>
> For every possible way that H can be encoded and D(D)
> calls H(D,D) either H(D,D) aborts its simulation or D(D)
> never stops running.
>
> It will not halt unless it aborts its simulation.

Nope.

Proof by Strawman is not proof.

YOu have shown that for every D built on an H that does not abort, that
H would have been justified to abort, but didn't.

You haven't shown ANYTHING about the behavior of any of the inputs wher
D built on an H tht does abort, except it didn't abort by the time that
H aborted.

UTM(D,D) Halts, so H did not "NEED" to abort by your accept criteria, or
are you going to lie that you never accepted it?

>
>> So, by THAT criteria, H(D,D) is only correct to abort it simulation if
>> UTM(D,D) fails to Halt,
>
> Not at all. H(D,D) aborts its simulation when not aborting
> its simulation would cause H(D,D) itself to never halt.
>

So, you beleive lying is ok?

That you can talk about an H not aborting when it DOES, and to do that
lie you change the input to be a different input that uses a different H
than what it was defined to use?

Or, are you just stupid as to think that a program defined to abort its
simulation at a given point can somehow "forget" to abort at that point
and continue to simulate.

Your whole argument is based on LYING, because you are nothing but a
pathetic ignornant pathological lying idiot.

On 3/17/24 4:48 PM, olcott wrote:
> On 3/17/2024 2:39 PM, Richard Damon wrote:
>> On 3/17/24 6:52 AM, olcott wrote:
>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>
>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>
>>>>>>> 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).
>>>>>>
>>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>>> the same.
>>>>>>
>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>> not meet the specification of halting decider it does not matter
>>>>>> what it meets instead.
>>>>>>
>>>>>
>>>>> The original halt status criteria has the impossible requirement
>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>
>>>> The requirement is not specifically about behaviour that the decider
>>>> does not actually see but requires reporting anyway, whether the
>>>> decider sees or not. So it turns out that it is not possible to
>>>> meet the specification in all cases.
>>>>
>>> I think that the decider can meet its abort criteria in all cases.
>>
>> Then show HOW.
>>
>> "I think" is not proof, especially from you.
>>
>
> The non-existence of counter-examples is proof.
>

Nope.

If you can PROVE there is no counter-examples, then you have a proof.

But just not having seen one just makes you a believer in the Russell
Teapot, and shows you don't understand logic.

This case is the counter example, D(D) Halts while your claim is you can
prove it doesn't.

Thus, you are shown to be just a ordinarly LIAR, since you know that.

On 3/17/2024 9:35 PM, Richard Damon wrote:
> On 3/17/24 4:27 PM, olcott wrote:
>> On 3/17/2024 12:37 PM, immibis wrote:
>>> On 17/03/24 14:11, olcott wrote:
>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>
>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>> And what defines "Need"?
>>>>>>>>>
>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>
>>>>>>>
>>>>>>> And thus not a specific algorithm?
>>>>>>>
>>>>>>> Again, HOW do you determine NEED?
>>>>>>>
>>>>>>> That is not an algorithmic step.
>>>>>>>
>>>>>>> We can only verify that in retrospect.
>>>>>>
>>>>>> Do you fully understand the spec?
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but I think not the way you do.
>>>>>
>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>
>>>> Yes that is correct.
>>>
>>> You have just proven that H doesn't need abort its simulation and the
>>> abort decision is incorrect.
>>
>> The head games of a Troll.
>>
>> For every possible way that H can be encoded and D(D)
>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>> never stops running.
>>
>
> Which prove NOTHING, as D varies with H, so no D that was built with an
> H that aborts its simulation has had its actual halting status tested.
>

*That merely changes the wording of the same truism*
∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
H(D,D) does not abort its simulation necessitates simulated D(D)
never stops running.

--
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/17/2024 9:35 PM, Richard Damon wrote:
> On 3/17/24 4:27 PM, olcott wrote:
>> On 3/17/2024 12:37 PM, immibis wrote:
>>> On 17/03/24 14:11, olcott wrote:
>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>
>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>> And what defines "Need"?
>>>>>>>>>
>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>
>>>>>>>
>>>>>>> And thus not a specific algorithm?
>>>>>>>
>>>>>>> Again, HOW do you determine NEED?
>>>>>>>
>>>>>>> That is not an algorithmic step.
>>>>>>>
>>>>>>> We can only verify that in retrospect.
>>>>>>
>>>>>> Do you fully understand the spec?
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but I think not the way you do.
>>>>>
>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>
>>>> Yes that is correct.
>>>
>>> You have just proven that H doesn't need abort its simulation and the
>>> abort decision is incorrect.
>>
>> The head games of a Troll.
>>
>> For every possible way that H can be encoded and D(D)
>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>> never stops running.
>>
>
> Which prove NOTHING, as D varies with H, so no D that was built with an
> H that aborts its simulation has had its actual halting status tested.

*That merely changes the wording of the same truism*
∀H ∈ TM ∀D ∈ TMD such that H(D,D) simulates its input and
D calls H(D,D) H(D,D) does not abort its simulation necessitates
simulated D(D) never stops running.

--
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/17/2024 9:35 PM, Richard Damon wrote:
> On 3/17/24 4:27 PM, olcott wrote:
>> On 3/17/2024 12:37 PM, immibis wrote:
>>> On 17/03/24 14:11, olcott wrote:
>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>
>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>> And what defines "Need"?
>>>>>>>>>
>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>
>>>>>>>
>>>>>>> And thus not a specific algorithm?
>>>>>>>
>>>>>>> Again, HOW do you determine NEED?
>>>>>>>
>>>>>>> That is not an algorithmic step.
>>>>>>>
>>>>>>> We can only verify that in retrospect.
>>>>>>
>>>>>> Do you fully understand the spec?
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but I think not the way you do.
>>>>>
>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>
>>>> Yes that is correct.
>>>
>>> You have just proven that H doesn't need abort its simulation and the
>>> abort decision is incorrect.
>>
>> The head games of a Troll.
>>
>> For every possible way that H can be encoded and D(D)
>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>> never stops running.
>>
>
> Which prove NOTHING, as D varies with H, so no D that was built with an
> H that aborts its simulation has had its actual halting status tested.

*That merely changes the wording of the same truism*
∀H ∈ TM ∀D ∈ TMD such that
H(D,D) simulates its input and
D calls H(D,D) and
H(D,D) does not abort its simulation
necessitates simulated D(D) never stops running.

--
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/17/2024 10:14 PM, olcott wrote:
> On 3/17/2024 9:35 PM, Richard Damon wrote:
>> On 3/17/24 4:27 PM, olcott wrote:
>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>> On 17/03/24 14:11, olcott wrote:
>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>
>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>
>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus not a specific algorithm?
>>>>>>>>
>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>
>>>>>>>> That is not an algorithmic step.
>>>>>>>>
>>>>>>>> We can only verify that in retrospect.
>>>>>>>
>>>>>>> Do you fully understand the spec?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but I think not the way you do.
>>>>>>
>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>> halt.
>>>>>>
>>>>> Yes that is correct.
>>>>
>>>> You have just proven that H doesn't need abort its simulation and
>>>> the abort decision is incorrect.
>>>
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Which prove NOTHING, as D varies with H, so no D that was built with
>> an H that aborts its simulation has had its actual halting status tested.
>
> *That merely changes the wording of the same truism*
> ∀H ∈ TM ∀D ∈ TMD such that
> H(D,D) simulates its input and
> D calls H(D,D) and
> H(D,D) does not abort its simulation
> necessitates simulated D(D) never stops running.
>

On 3/17/24 8:07 PM, olcott wrote:
> On 3/17/2024 9:35 PM, Richard Damon wrote:
>> On 3/17/24 4:27 PM, olcott wrote:
>>> On 3/17/2024 12:37 PM, immibis wrote:

>>>> You have just proven that H doesn't need abort its simulation and
>>>> the abort decision is incorrect.
>>>
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Which prove NOTHING, as D varies with H, so no D that was built with
>> an H that aborts its simulation has had its actual halting status tested.
>>
>
> *That merely changes the wording of the same truism*
> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
> H(D,D) does not abort its simulation necessitates simulated D(D)
> never stops running.
>

Nope, that only proves that D that call H's that don't abort their
simulation never stop running.

Your logic is too sloppy.

You miss that if D calls an H that does abort its simulation, and
returns 0, then that D will Halt and thus its simulation will halt, and
thus will be correctly decided by any other H that doesn't abort its
simulation, and thus the Hs that DID abort their simulation didn't need
to and are just wrong.

You are just proving your utter stupidity, and dishonesty.

On 3/17/24 8:12 PM, olcott wrote:
> On 3/17/2024 9:35 PM, Richard Damon wrote:
>> On 3/17/24 4:27 PM, olcott wrote:
>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>> On 17/03/24 14:11, olcott wrote:
>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>
>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>
>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus not a specific algorithm?
>>>>>>>>
>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>
>>>>>>>> That is not an algorithmic step.
>>>>>>>>
>>>>>>>> We can only verify that in retrospect.
>>>>>>>
>>>>>>> Do you fully understand the spec?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but I think not the way you do.
>>>>>>
>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>> halt.
>>>>>>
>>>>> Yes that is correct.
>>>>
>>>> You have just proven that H doesn't need abort its simulation and
>>>> the abort decision is incorrect.
>>>
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Which prove NOTHING, as D varies with H, so no D that was built with
>> an H that aborts its simulation has had its actual halting status tested.
>
> *That merely changes the wording of the same truism*
> ∀H ∈ TM ∀D ∈  TMD such that H(D,D) simulates its input and
> D calls H(D,D) H(D,D) does not abort its simulation necessitates
> simulated D(D) never stops running.
>
>

On 3/17/2024 7:27 PM, immibis wrote:
> On 18/03/24 00:27, olcott wrote:
>> On 3/17/2024 12:37 PM, immibis wrote:
>>> On 17/03/24 14:11, olcott wrote:
>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting
>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no
>>>>>>>>>>>>>>>>> concept of real truth,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove
>>>>>>>>>>>>> what you need it to.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>
>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Nope.
>>>>>>>>>>
>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>> And what defines "Need"?
>>>>>>>>>
>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>
>>>>>>>
>>>>>>> And thus not a specific algorithm?
>>>>>>>
>>>>>>> Again, HOW do you determine NEED?
>>>>>>>
>>>>>>> That is not an algorithmic step.
>>>>>>>
>>>>>>> We can only verify that in retrospect.
>>>>>>
>>>>>> Do you fully understand the spec?
>>>>>>
>>>>>>
>>>>>
>>>>> Yes, but I think not the way you do.
>>>>>
>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>
>>>> Yes that is correct.
>>>
>>> You have just proven that H doesn't need abort its simulation and the
>>> abort decision is incorrect.
>>
>> The head games of a Troll.
>>
>> For every possible way that H can be encoded and D(D)
>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>> never stops running.
>>
>
> Wrong.

So you want me to start ignoring all your of your posts?
--
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/17/24 8:14 PM, olcott wrote:
> On 3/17/2024 9:35 PM, Richard Damon wrote:
>> On 3/17/24 4:27 PM, olcott wrote:
>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>> On 17/03/24 14:11, olcott wrote:
>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the
>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig
>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>
>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Nope.
>>>>>>>>>>>
>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>
>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>
>>>>>>>>
>>>>>>>> And thus not a specific algorithm?
>>>>>>>>
>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>
>>>>>>>> That is not an algorithmic step.
>>>>>>>>
>>>>>>>> We can only verify that in retrospect.
>>>>>>>
>>>>>>> Do you fully understand the spec?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yes, but I think not the way you do.
>>>>>>
>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>> halt.
>>>>>>
>>>>> Yes that is correct.
>>>>
>>>> You have just proven that H doesn't need abort its simulation and
>>>> the abort decision is incorrect.
>>>
>>> The head games of a Troll.
>>>
>>> For every possible way that H can be encoded and D(D)
>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>> never stops running.
>>>
>>
>> Which prove NOTHING, as D varies with H, so no D that was built with
>> an H that aborts its simulation has had its actual halting status tested.
>
> *That merely changes the wording of the same truism*
> ∀H ∈ TM ∀D ∈ TMD such that
> H(D,D) simulates its input and
> D calls H(D,D) and
> H(D,D) does not abort its simulation
> necessitates simulated D(D) never stops running.
>
>

On 3/17/24 8:17 PM, olcott wrote:
> On 3/17/2024 10:14 PM, olcott wrote:
>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>> On 3/17/24 4:27 PM, olcott wrote:
>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of
>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> (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*
>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H
>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior
>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>
>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>
>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>
>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>
>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>
>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>
>>>>>>>> Do you fully understand the spec?
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yes, but I think not the way you do.
>>>>>>>
>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>> when giving the input to a correct simulator, that simulator will
>>>>>>> not halt.
>>>>>>>
>>>>>> Yes that is correct.
>>>>>
>>>>> You have just proven that H doesn't need abort its simulation and
>>>>> the abort decision is incorrect.
>>>>
>>>> The head games of a Troll.
>>>>
>>>> For every possible way that H can be encoded and D(D)
>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>> never stops running.
>>>>
>>>
>>> Which prove NOTHING, as D varies with H, so no D that was built with
>>> an H that aborts its simulation has had its actual halting status
>>> tested.
>>
>> *That merely changes the wording of the same truism*
>> ∀H ∈ TM ∀D ∈ TMD such that
>> H(D,D) simulates its input and
>> D calls H(D,D) and
>> H(D,D) does not abort its simulation
>> necessitates simulated D(D) never stops running.
>>
>
> It is like I am saying that all dead people are not alive
> and your rebuttal is if they are not dead then they are alive.
>