On 15/03/24 03:29, olcott wrote:
>
> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
> *original criteria because it does meet the above criteria*
>
> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (2) which begins at simulated ⟨Ĥ.q0⟩
> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>
> The earliest point when Turing machine H can detect the repeating

Whensoever H detects the repeating state and aborts it is incorrect
because the state is not repeating. The state is repeating if H does not
detect the repeating state.

On 3/14/2024 9:34 PM, immibis wrote:
> On 15/03/24 03:29, olcott wrote:
>>
>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>> *original criteria because it does meet the above criteria*
>>
>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (2) which begins at simulated ⟨Ĥ.q0⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> The earliest point when Turing machine H can detect the repeating
>
> Whensoever H detects the repeating state and aborts it is incorrect
> because the state is not repeating. The state is repeating if H does not
> detect the repeating state.

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.

--
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/14/2024 10:18 PM, Richard Damon wrote:
> On 3/14/24 7:29 PM, olcott wrote:
>> On 3/14/2024 9:08 PM, Richard Damon wrote:
>>> On 3/14/24 6:02 PM, olcott wrote:
>>>> On 3/14/2024 7:59 PM, Richard Damon wrote:
>>>>> On 3/14/24 5:01 PM, olcott wrote:
>>>>>> On 3/14/2024 5:21 PM, Richard Damon wrote:
>>>>>>> On 3/14/24 2:49 PM, olcott wrote:
>>>>>>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>>>>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>>>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> slightly augmented
>>>>>>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> An important question to answer is whether a
>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine can
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a
>>>>>>>>>>>>>>>>>>>>>>>>>> UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append
>>>>>>>>>>>>>>>>>>>>>>>>>> the TMD to the end
>>>>>>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot
>>>>>>>>>>>>>>>>>>>>>>>> be an Olcott machine.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in what
>>>>>>>>>>>>>>>>>>>>>>> the word "Truring machine"
>>>>>>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation of
>>>>>>>>>>>>>>>>>>>>>>> your machine, compute
>>>>>>>>>>>>>>>>>>>>>>> everything your machine can, so your machine
>>>>>>>>>>>>>>>>>>>>>>> cannot compute anyting a
>>>>>>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines
>>>>>>>>>>>>>>>>>>>>>> and my C functions
>>>>>>>>>>>>>>>>>>>>>> can always correctly report on the behavior of
>>>>>>>>>>>>>>>>>>>>>> their actual input
>>>>>>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If they only talk about themselves they are not
>>>>>>>>>>>>>>>>>>>>> useful.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> When every simulating halt decider reports on the
>>>>>>>>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>>>>>>>>> that it actually sees, then the pathological input
>>>>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> If it is not useful then nobody cares whether some
>>>>>>>>>>>>>>>>>>> input can thwart it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input won't
>>>>>>>>>>>>>>>>> stop, can H abort its simlation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Of course, if H aborts it simulation, then BY
>>>>>>>>>>>>>>>>> DEFINITION, its simulation doesn't go on forever and
>>>>>>>>>>>>>>>>> isn't a correct simulation, so that doesn't apply.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is your persistently repeated mistake that has been
>>>>>>>>>>>>>>>> corrected
>>>>>>>>>>>>>>>> hundreds of times that a correct simulation requires a
>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The words that Professor Sipser agreed to clearly mean that
>>>>>>>>>>>>>>>> when a correct partial simulation of D proves that a
>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>> complete simulation of D would never stop running then H
>>>>>>>>>>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope, because there is no such thing in Computation theory.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Only in your incorrect reconstruction from lack of
>>>>>>>>>>>>>>> principles.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of it.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> "simulates its input D until"
>>>>>>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But you said:
>>>>>>>>>>>>>
>>>>>>>>>>>>> ... until H correctly determines that its simulated D would
>>>>>>>>>>>>> never stop running unless aborted
>>>>>>>>>>>>>
>>>>>>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>>>>>>
>>>>>>>>>>> But "would never stop" clearly does.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Only when you ignore the rest of the sentence.
>>>>>>>>>> "simulated D would never stop running {unless aborted}
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> But it DOES, The simulated D uses the H that is your final
>>>>>>>>> decison on what H does, which will abort and return 0, so any
>>>>>>>>> correct simulation of D will reach an end and stop running.
>>>>>>>>>
>>>>>>>>
>>>>>>>> When we simply comment out the part where H aborts and then D(D)
>>>>>>>> never stops this is proof that weasel words cannot actually thwart.
>>>>>>>
>>>>>>> Which means (by your constructio) that you changed D.
>>>>>>>
>>>>>>> You need D to still call the version that still had that abort in
>>>>>>> it.
>>>>>>>
>>>>>>
>>>>>> Pathological Weasel words just don't work.
>>>>>>
>>>>>> It is like you are saying that when someone goes back in time
>>>>>> to kill Hitler so he does not murder six millions Jews this is
>>>>>> proven to have never been needed when after they kill Hitler
>>>>>> the six million Jews are never murdered.
>>>>> Nope, Red Herring. Not the same. And the Time Travel introduces
>>>>> Paradox.
>>>>>
>>>>> It would be more like if your partner went back and killed Hitler,
>>>>> you wouldn't need to go again yourself.
>>>>>
>>>>>
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>
>>>>> Right, because THIS COPY of H doesn't, since the other copy DID.
>>>>>
>>>>> They are different machines (with the same algorithm), so different
>>>>> Identites.
>>>>>
>>>>
>>>> Thus admitting that this criteria is met by H(D,D).
>>>>
>>>> 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.
>>>>
>>>>
>>>
>>> Nope.
>>>
>>> YOUR TOP Copy of H can't CORRECTLY DETERMINE that a correct
>>> simulation of the input will be non-halting, because it Halts, since
>>> your H(D,D) reteurn 0.
>>>
>>
>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>> *original criteria because it does meet the above criteria*
>
> The ONLY criteria is that the input (or a full complete simulation of
> it) will not halt.
>

On 3/14/2024 10:55 PM, Richard Damon wrote:
> On 3/14/24 8:29 PM, olcott wrote:
>> On 3/14/2024 10:18 PM, Richard Damon wrote:
>>> On 3/14/24 7:29 PM, olcott wrote:
>>>> On 3/14/2024 9:08 PM, Richard Damon wrote:
>>>>> On 3/14/24 6:02 PM, olcott wrote:
>>>>>> On 3/14/2024 7:59 PM, Richard Damon wrote:
>>>>>>> On 3/14/24 5:01 PM, olcott wrote:
>>>>>>>> On 3/14/2024 5:21 PM, Richard Damon wrote:
>>>>>>>>> On 3/14/24 2:49 PM, olcott wrote:
>>>>>>>>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Peaks said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> slightly augmented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An important question to answer is whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a Turing machine can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the end
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot
>>>>>>>>>>>>>>>>>>>>>>>>>> be an Olcott machine.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in what
>>>>>>>>>>>>>>>>>>>>>>>>> the word "Truring machine"
>>>>>>>>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation
>>>>>>>>>>>>>>>>>>>>>>>>> of your machine, compute
>>>>>>>>>>>>>>>>>>>>>>>>> everything your machine can, so your machine
>>>>>>>>>>>>>>>>>>>>>>>>> cannot compute anyting a
>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines
>>>>>>>>>>>>>>>>>>>>>>>> and my C functions
>>>>>>>>>>>>>>>>>>>>>>>> can always correctly report on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>> their actual input
>>>>>>>>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If they only talk about themselves they are not
>>>>>>>>>>>>>>>>>>>>>>> useful.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When every simulating halt decider reports on the
>>>>>>>>>>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>>>>>>>>>>> that it actually sees, then the pathological input
>>>>>>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If it is not useful then nobody cares whether some
>>>>>>>>>>>>>>>>>>>>> input can thwart it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input
>>>>>>>>>>>>>>>>>>> won't stop, can H abort its simlation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Of course, if H aborts it simulation, then BY
>>>>>>>>>>>>>>>>>>> DEFINITION, its simulation doesn't go on forever and
>>>>>>>>>>>>>>>>>>> isn't a correct simulation, so that doesn't apply.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is your persistently repeated mistake that has been
>>>>>>>>>>>>>>>>>> corrected
>>>>>>>>>>>>>>>>>> hundreds of times that a correct simulation requires a
>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The words that Professor Sipser agreed to clearly mean
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> when a correct partial simulation of D proves that a
>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>> complete simulation of D would never stop running then H
>>>>>>>>>>>>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, because there is no such thing in Computation
>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Only in your incorrect reconstruction from lack of
>>>>>>>>>>>>>>>>> principles.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of
>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> "simulates its input D until"
>>>>>>>>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But you said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ... until H correctly determines that its simulated D
>>>>>>>>>>>>>>> would never stop running unless aborted
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But "would never stop" clearly does.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Only when you ignore the rest of the sentence.
>>>>>>>>>>>> "simulated D would never stop running {unless aborted}
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But it DOES, The simulated D uses the H that is your final
>>>>>>>>>>> decison on what H does, which will abort and return 0, so any
>>>>>>>>>>> correct simulation of D will reach an end and stop running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When we simply comment out the part where H aborts and then D(D)
>>>>>>>>>> never stops this is proof that weasel words cannot actually
>>>>>>>>>> thwart.
>>>>>>>>>
>>>>>>>>> Which means (by your constructio) that you changed D.
>>>>>>>>>
>>>>>>>>> You need D to still call the version that still had that abort
>>>>>>>>> in it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Pathological Weasel words just don't work.
>>>>>>>>
>>>>>>>> It is like you are saying that when someone goes back in time
>>>>>>>> to kill Hitler so he does not murder six millions Jews this is
>>>>>>>> proven to have never been needed when after they kill Hitler
>>>>>>>> the six million Jews are never murdered.
>>>>>>> Nope, Red Herring. Not the same. And the Time Travel introduces
>>>>>>> Paradox.
>>>>>>>
>>>>>>> It would be more like if your partner went back and killed
>>>>>>> Hitler, you wouldn't need to go again yourself.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>
>>>>>>>
>>>>>>> Right, because THIS COPY of H doesn't, since the other copy DID.
>>>>>>>
>>>>>>> They are different machines (with the same algorithm), so
>>>>>>> different Identites.
>>>>>>>
>>>>>>
>>>>>> Thus admitting that this criteria is met by H(D,D).
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> YOUR TOP Copy of H can't CORRECTLY DETERMINE that a correct
>>>>> simulation of the input will be non-halting, because it Halts,
>>>>> since your H(D,D) reteurn 0.
>>>>>
>>>>
>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>> *original criteria because it does meet the above criteria*
>>>
>>> The ONLY criteria is that the input (or a full complete simulation of
>>> it) will not 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.
>>
>
> Right, because when you look at D as the Turing Equivalent of H^, and
> thus is considered to have its own copy of H (or else you whole system
> needs to be thrown out as a big lie).

On 3/14/2024 11:24 PM, Richard Damon wrote:
> On 3/14/24 9:06 PM, olcott wrote:
>> On 3/14/2024 10:55 PM, Richard Damon wrote:
>>> On 3/14/24 8:29 PM, olcott wrote:
>>>> On 3/14/2024 10:18 PM, Richard Damon wrote:
>>>>> On 3/14/24 7:29 PM, olcott wrote:
>>>>>> On 3/14/2024 9:08 PM, Richard Damon wrote:
>>>>>>> On 3/14/24 6:02 PM, olcott wrote:
>>>>>>>> On 3/14/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>> On 3/14/24 5:01 PM, olcott wrote:
>>>>>>>>>> On 3/14/2024 5:21 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/14/24 2:49 PM, olcott wrote:
>>>>>>>>>>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Peaks said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> slightly augmented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An important question to answer is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether a Turing machine can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the end
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot be an Olcott machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in
>>>>>>>>>>>>>>>>>>>>>>>>>>> what the word "Truring machine"
>>>>>>>>>>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of your machine, compute
>>>>>>>>>>>>>>>>>>>>>>>>>>> everything your machine can, so your machine
>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot compute anyting a
>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP
>>>>>>>>>>>>>>>>>>>>>>>>>> machines and my C functions
>>>>>>>>>>>>>>>>>>>>>>>>>> can always correctly report on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>>>> their actual input
>>>>>>>>>>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If they only talk about themselves they are not
>>>>>>>>>>>>>>>>>>>>>>>>> useful.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> When every simulating halt decider reports on
>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>> that it actually sees, then the pathological
>>>>>>>>>>>>>>>>>>>>>>>> input does not
>>>>>>>>>>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If it is not useful then nobody cares whether
>>>>>>>>>>>>>>>>>>>>>>> some input can thwart it.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input
>>>>>>>>>>>>>>>>>>>>> won't stop, can H abort its simlation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Of course, if H aborts it simulation, then BY
>>>>>>>>>>>>>>>>>>>>> DEFINITION, its simulation doesn't go on forever
>>>>>>>>>>>>>>>>>>>>> and isn't a correct simulation, so that doesn't apply.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> It is your persistently repeated mistake that has
>>>>>>>>>>>>>>>>>>>> been corrected
>>>>>>>>>>>>>>>>>>>> hundreds of times that a correct simulation requires
>>>>>>>>>>>>>>>>>>>> a complete
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The words that Professor Sipser agreed to clearly
>>>>>>>>>>>>>>>>>>>> mean that
>>>>>>>>>>>>>>>>>>>> when a correct partial simulation of D proves that a
>>>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>>>> complete simulation of D would never stop running
>>>>>>>>>>>>>>>>>>>> then H
>>>>>>>>>>>>>>>>>>>> has both its abort criteria and its halt status
>>>>>>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope, because there is no such thing in Computation
>>>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Only in your incorrect reconstruction from lack of
>>>>>>>>>>>>>>>>>>> principles.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking
>>>>>>>>>>>>>>>>>>> of it.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> "simulates its input D until"
>>>>>>>>>>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But you said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> ... until H correctly determines that its simulated D
>>>>>>>>>>>>>>>>> would never stop running unless aborted
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But "would never stop" clearly does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Only when you ignore the rest of the sentence.
>>>>>>>>>>>>>> "simulated D would never stop running {unless aborted}
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> But it DOES, The simulated D uses the H that is your final
>>>>>>>>>>>>> decison on what H does, which will abort and return 0, so
>>>>>>>>>>>>> any correct simulation of D will reach an end and stop
>>>>>>>>>>>>> running.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When we simply comment out the part where H aborts and then
>>>>>>>>>>>> D(D)
>>>>>>>>>>>> never stops this is proof that weasel words cannot actually
>>>>>>>>>>>> thwart.
>>>>>>>>>>>
>>>>>>>>>>> Which means (by your constructio) that you changed D.
>>>>>>>>>>>
>>>>>>>>>>> You need D to still call the version that still had that
>>>>>>>>>>> abort in it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Pathological Weasel words just don't work.
>>>>>>>>>>
>>>>>>>>>> It is like you are saying that when someone goes back in time
>>>>>>>>>> to kill Hitler so he does not murder six millions Jews this is
>>>>>>>>>> proven to have never been needed when after they kill Hitler
>>>>>>>>>> the six million Jews are never murdered.
>>>>>>>>> Nope, Red Herring. Not the same. And the Time Travel introduces
>>>>>>>>> Paradox.
>>>>>>>>>
>>>>>>>>> It would be more like if your partner went back and killed
>>>>>>>>> Hitler, you wouldn't need to go again yourself.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Right, because THIS COPY of H doesn't, since the other copy DID.
>>>>>>>>>
>>>>>>>>> They are different machines (with the same algorithm), so
>>>>>>>>> different Identites.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Thus admitting that this criteria is met by H(D,D).
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Nope.
>>>>>>>
>>>>>>> YOUR TOP Copy of H can't CORRECTLY DETERMINE that a correct
>>>>>>> simulation of the input will be non-halting, because it Halts,
>>>>>>> since your H(D,D) reteurn 0.
>>>>>>>
>>>>>>
>>>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>>>> *original criteria because it does meet the above criteria*
>>>>>
>>>>> The ONLY criteria is that the input (or a full complete simulation
>>>>> of it) will not 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.
>>>>
>>>
>>> Right, because when you look at D as the Turing Equivalent of H^, and
>>> thus is considered to have its own copy of H (or else you whole
>>> system needs to be thrown out as a big lie).
>>
>> We can look at both separately.
>> First we are looking at H(D,D).
>>
>> I cannot afford to tolerate the [change the subject]
>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>
> So, what was wrong with my argument?
>
You changed the subject from H(D,D).

On 3/15/2024 12:10 AM, Richard Damon wrote:
> On 3/14/24 9:29 PM, olcott wrote:
>> On 3/14/2024 11:24 PM, Richard Damon wrote:
>>> On 3/14/24 9:06 PM, olcott wrote:
>>>> On 3/14/2024 10:55 PM, Richard Damon wrote:
>>>>> On 3/14/24 8:29 PM, olcott wrote:
>>>>>> On 3/14/2024 10:18 PM, Richard Damon wrote:
>>>>>>> On 3/14/24 7:29 PM, olcott wrote:
>>>>>>>> On 3/14/2024 9:08 PM, Richard Damon wrote:
>>>>>>>>> On 3/14/24 6:02 PM, olcott wrote:
>>>>>>>>>> On 3/14/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/14/24 5:01 PM, olcott wrote:
>>>>>>>>>>>> On 3/14/2024 5:21 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/14/24 2:49 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Peaks said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> aren't you working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Andre pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> with turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> formulate similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a slightly augmented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> elaborated below:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An important question to answer is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> whether a Turing machine can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the end
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> cannot be an Olcott machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> what the word "Truring machine"
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of your machine, compute
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> everything your machine can, so your
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> machine cannot compute anyting a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP
>>>>>>>>>>>>>>>>>>>>>>>>>>>> machines and my C functions
>>>>>>>>>>>>>>>>>>>>>>>>>>>> can always correctly report on the behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of their actual input
>>>>>>>>>>>>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation?
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> If they only talk about themselves they are
>>>>>>>>>>>>>>>>>>>>>>>>>>> not useful.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> When every simulating halt decider reports on
>>>>>>>>>>>>>>>>>>>>>>>>>> the actual behavior
>>>>>>>>>>>>>>>>>>>>>>>>>> that it actually sees, then the pathological
>>>>>>>>>>>>>>>>>>>>>>>>>> input does not
>>>>>>>>>>>>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> If it is not useful then nobody cares whether
>>>>>>>>>>>>>>>>>>>>>>>>> some input can thwart it.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input
>>>>>>>>>>>>>>>>>>>>>>> won't stop, can H abort its simlation.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Of course, if H aborts it simulation, then BY
>>>>>>>>>>>>>>>>>>>>>>> DEFINITION, its simulation doesn't go on forever
>>>>>>>>>>>>>>>>>>>>>>> and isn't a correct simulation, so that doesn't
>>>>>>>>>>>>>>>>>>>>>>> apply.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> It is your persistently repeated mistake that has
>>>>>>>>>>>>>>>>>>>>>> been corrected
>>>>>>>>>>>>>>>>>>>>>> hundreds of times that a correct simulation
>>>>>>>>>>>>>>>>>>>>>> requires a complete
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The words that Professor Sipser agreed to clearly
>>>>>>>>>>>>>>>>>>>>>> mean that
>>>>>>>>>>>>>>>>>>>>>> when a correct partial simulation of D proves that
>>>>>>>>>>>>>>>>>>>>>> a correct
>>>>>>>>>>>>>>>>>>>>>> complete simulation of D would never stop running
>>>>>>>>>>>>>>>>>>>>>> then H
>>>>>>>>>>>>>>>>>>>>>> has both its abort criteria and its halt status
>>>>>>>>>>>>>>>>>>>>>> criteria.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope, because there is no such thing in Computation
>>>>>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Only in your incorrect reconstruction from lack of
>>>>>>>>>>>>>>>>>>>>> principles.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even
>>>>>>>>>>>>>>>>>>>>> thinking of it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> "simulates its input D until"
>>>>>>>>>>>>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But you said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> ... until H correctly determines that its simulated D
>>>>>>>>>>>>>>>>>>> would never stop running unless aborted
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But "would never stop" clearly does.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Only when you ignore the rest of the sentence.
>>>>>>>>>>>>>>>> "simulated D would never stop running {unless aborted}
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But it DOES, The simulated D uses the H that is your
>>>>>>>>>>>>>>> final decison on what H does, which will abort and return
>>>>>>>>>>>>>>> 0, so any correct simulation of D will reach an end and
>>>>>>>>>>>>>>> stop running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> When we simply comment out the part where H aborts and
>>>>>>>>>>>>>> then D(D)
>>>>>>>>>>>>>> never stops this is proof that weasel words cannot
>>>>>>>>>>>>>> actually thwart.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Which means (by your constructio) that you changed D.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You need D to still call the version that still had that
>>>>>>>>>>>>> abort in it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Pathological Weasel words just don't work.
>>>>>>>>>>>>
>>>>>>>>>>>> It is like you are saying that when someone goes back in time
>>>>>>>>>>>> to kill Hitler so he does not murder six millions Jews this is
>>>>>>>>>>>> proven to have never been needed when after they kill Hitler
>>>>>>>>>>>> the six million Jews are never murdered.
>>>>>>>>>>> Nope, Red Herring. Not the same. And the Time Travel
>>>>>>>>>>> introduces Paradox.
>>>>>>>>>>>
>>>>>>>>>>> It would be more like if your partner went back and killed
>>>>>>>>>>> Hitler, you wouldn't need to go again yourself.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Right, because THIS COPY of H doesn't, since the other copy DID.
>>>>>>>>>>>
>>>>>>>>>>> They are different machines (with the same algorithm), so
>>>>>>>>>>> different Identites.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Thus admitting that this criteria is met by H(D,D).
>>>>>>>>>>
>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Nope.
>>>>>>>>>
>>>>>>>>> YOUR TOP Copy of H can't CORRECTLY DETERMINE that a correct
>>>>>>>>> simulation of the input will be non-halting, because it Halts,
>>>>>>>>> since your H(D,D) reteurn 0.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>>>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>>>>>> *original criteria because it does meet the above criteria*
>>>>>>>
>>>>>>> The ONLY criteria is that the input (or a full complete
>>>>>>> simulation of it) will not 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.
>>>>>>
>>>>>
>>>>> Right, because when you look at D as the Turing Equivalent of H^,
>>>>> and thus is considered to have its own copy of H (or else you whole
>>>>> system needs to be thrown out as a big lie).
>>>>
>>>> We can look at both separately.
>>>> First we are looking at H(D,D).
>>>>
>>>> I cannot afford to tolerate the [change the subject]
>>>> form of rebuttal that wasted 15 years with Ben Bacarisse.
>>>
>>> So, what was wrong with my argument?
>>>
>> You changed the subject from H(D,D).
>>
>
> Then you admit that you H / D system isn't the correct Turing
> Equivalent, so was all just a strawman.
>
The H(D,D) level can lead to the H ⟨Ĥ⟩ ⟨Ĥ⟩.
We must finish one thing at a time.

Op 15.mrt.2024 om 03:40 schreef olcott:
> On 3/14/2024 9:34 PM, immibis wrote:
>> On 15/03/24 03:29, olcott wrote:
>>>
>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>> *original criteria because it does meet the above criteria*
>>>
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> The earliest point when Turing machine H can detect the repeating
>>
>> Whensoever H detects the repeating state and aborts it is incorrect
>> because the state is not repeating. The state is repeating if H does
>> not detect the repeating state.
>
> 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.
>

Do you finally understand it? Hah(Dah,Dah) does not need to abort,
because Dah halts. Hah should look at its input Dah (which aborts), not
at its non-input Dss (which does not abort).

On 2024-03-14 13:36:30 +0000, olcott said:

> On 3/14/2024 5:41 AM, Mikko wrote:
>> On 2024-03-13 17:03:03 +0000, olcott said:
>>
>>> On 3/13/2024 11:48 AM, immibis wrote:
>>>> On 13/03/24 06:24, olcott wrote:
>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>> input then it becomes a consistent undecidability decider.
>>>>
>>>> void E(finite_string argument) {
>>>>     H(argument, argument);
>>>> }
>>>>
>>>> this input is incorrectly detected as pathological.
>>>>
>>>
>>> I don't think so. H only takes the address of C functions.
>>
>> E calls H correctly if put the required typedef or #define
>> for finite_string in front of it and call E correctly.
>>
> H Is not designed to work on strings.
> It can work on short strings.
> The x86 emulator gets confused on large strings.
>
> Its detection algorithm must be changed.
> It currently does not do string comparisons.
> H must be able to see the body of E.

Don't try to use strings. Both arguments of H are of the
same type so it is possible to do what I said above.

--
Mikko

On 2024-03-14 16:36:33 +0000, immibis said:

> On 14/03/24 14:36, olcott wrote:
>> On 3/14/2024 5:41 AM, Mikko wrote:
>>> On 2024-03-13 17:03:03 +0000, olcott said:
>>>
>>>> On 3/13/2024 11:48 AM, immibis wrote:
>>>>> On 13/03/24 06:24, olcott wrote:
>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>> input then it becomes a consistent undecidability decider.
>>>>>
>>>>> void E(finite_string argument) {
>>>>>     H(argument, argument);
>>>>> }
>>>>>
>>>>> this input is incorrectly detected as pathological.
>>>>>
>>>>
>>>> I don't think so. H only takes the address of C functions.
>>>
>>> E calls H correctly if put the required typedef or #define
>>> for finite_string in front of it and call E correctly.
>>>
>> H Is not designed to work on strings.
>> It can work on short strings.
>> The x86 emulator gets confused on large strings.
>>
>> Its detection algorithm must be changed.
>> It currently does not do string comparisons.
>> H must be able to see the body of E.
>>
> The halting problem is about programs represented as finite strings.

If your only tool is a computer then everything is a finite string of
bits.

--
Mikko

On 2024-03-14 13:42:38 +0000, olcott said:

> On 3/14/2024 6:02 AM, Mikko wrote:
>> On 2024-03-13 21:14:17 +0000, immibis said:
>>
>>> On 13/03/24 21:54, olcott wrote:
>>>> On 3/13/2024 3:46 PM, immibis wrote:
>>>>> Actually, C functions can't access "my own address".
>>>>
>>>> *Denying verified facts is far too untruthful*
>>>> *Denying verified facts is far too untruthful*
>>>> *Denying verified facts is far too untruthful*
>>>>
>>>> u32 H(ptr P, ptr I)
>>>> {
>>>>   u32 End_Of_Code               = get_code_end((u32)H);
>>>>   u32 Address_of_H              = (u32)H;
>>>>
>>>>> They can only access addresses of named functions. You can write &H but
>>>>> you can't write &myself (unless the function is called myself).
>>>>>
>>>>> H contains &H but H1 contains &H1. They are different functions so any
>>>>> rebuttal based on the fact they are the same function is rejected as
>>>>> invalid.
>>>>
>>>
>>> do you see this code:
>>> (u32)H
>>> do you know what it means
>>
>> A C compiler may interprete it as an error and refuse to complie.
>> Alternative, it may interprete it as a cast of the last 32 bits
>> of the address of the function H to u32, as such non-standard
>> extensions are not prihibited.
>>
> The interpreter is int 32-bit mode.
> The author changed this for me.
> It used to be in 16-bit mode.

A 32 bit integer would not be a good choice if a machine address has
48 or 64 bits. And in any case, casting a function pointer to any
integer type means that the program is not strictly confoming.

--
Mikko

On 2024-03-14 20:34:30 +0000, olcott said:

> On 3/14/2024 8:46 AM, Mikko wrote:
>> On 2024-03-14 13:40:38 +0000, olcott said:
>>
>>> On 3/14/2024 5:50 AM, Mikko wrote:
>>>> On 2024-03-13 16:57:47 +0000, olcott said:
>>>>
>>>>>    u32 End_Of_Code   = get_code_end((u32)H);
>>>>
>>>> Do you have an get_code_end function? It is computable but
>>>> far from trivial, especially if the return instruction that
>>>> is usually at the end of the function is in the middle.
>>>>
>>>
>>> It looks for 0x90 NOP that pad the space between function bodies.
>>
>> Who ensures that there are no NOPs elsewhere and that there always
>> is one at the end?
>>
>
> The compiler uses another byte that I replace with 0x90.

Do you also verify that there is no 0x90 in the middle?
And what was wrong with that other byte?

--
Mikko

On 2024-03-14 13:44:52 +0000, olcott said:

> On 3/14/2024 6:09 AM, Mikko wrote:
>> On 2024-03-13 20:08:36 +0000, olcott said:
>>
>>> On 3/13/2024 1:29 PM, Mikko wrote:
>>>> On 2024-03-13 15:05:54 +0000, Richard Damon said:
>>>>
>>>>> On 3/13/24 7:14 AM, olcott wrote:
>>>>>> On 3/13/2024 1:17 AM, Richard Damon wrote:
>>>>>>> On 3/12/24 11:05 PM, olcott wrote:
>>>>>>>> On 3/13/2024 1:00 AM, Richard Damon wrote:
>>>>>>>>> On 3/12/24 10:43 PM, olcott wrote:
>>>>>>>>>> On 3/13/2024 12:36 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/12/24 10:26 PM, olcott wrote:
>>>>>>>>>>>> On 3/12/2024 11:50 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/12/24 8:42 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/12/2024 10:14 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 7:40 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 9:18 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 13/03/24 02:52, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 7:59 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/24 4:35 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 6:03 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You haven't actually shown that we have a paradox set, and in fact, ZFC
>>>>>>>>>>>>>>>>>>>>> prevents it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes and by changing the notion of undecidability to mean
>>>>>>>>>>>>>>>>>>>> semantically incorrect input we get the exact same results.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> That seems to be your habit, trying to just LIE and redefine terms and
>>>>>>>>>>>>>>>>>>> then still try to be in the same logic system.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am doing the same thing that ZFC did to Naive set theory.
>>>>>>>>>>>>>>>>>> My new foundation for computation (NFFC).
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You want to say that some ⟨Q, Γ, b, Σ, δ, q0, F⟩ aren't real Turing
>>>>>>>>>>>>>>>>> machines, right? Just like Russell said that some {x|P(x)} aren't real
>>>>>>>>>>>>>>>>> sets?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> H(D,D) can simply terminate abnormally like a divide by
>>>>>>>>>>>>>>>> zero exception when it detects pathological self-reference.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Turing Machines don't "Terminate Abnormally" as that isn't an option for them.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H COULD halt in a state other than qy or qn and thus make itself wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> This might be a reasonable extension for a decider, Accept, Reject, and
>>>>>>>>>>>>>>> an "I can't tell". The key is to somehow limit where "I can't tell" can
>>>>>>>>>>>>>>> be used, or it makes the decider useless.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Could be a LOT better (but still not meet the original requrements)
>>>>>>>>>>>>>>> then lying by going to Accept or Reject incorrectly.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> So tentative progress until we see if H(D,D) can be fooled.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> IF H ever answer "I don't know" it isn't a Halt Decider.
>>>>>>>>>>>>>
>>>>>>>>>>>> If H(D,D) can always abnormally terminate on pathological
>>>>>>>>>>>> input then it becomes a consistent undecidability decider.
>>>>>>>>>>>
>>>>>>>>>>> If your "abnormal Termination" is defined so that it always stops the
>>>>>>>>>>> machine it is embedded in, then the operation isn't part of a
>>>>>>>>>>> computation, and become a "non-answer" result, and thus make the claim
>>>>>>>>>>> decider fail.
>>>>>>>>>>>
>>>>>>>>>> Then it returns 0,1,2
>>>>>>>>>
>>>>>>>>> Thats fine. or -1, 0, 1
>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>> That is how the definitions work. If another machine can't get the
>>>>>>>>>>> answer by embedding you, it isn't an answer, and you are not a
>>>>>>>>>>> computation.
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>>> Like I say, it might be an intersting alternate problem, but it doesn't
>>>>>>>>>>>>> change the verdict on Halt Deciders, as it doesn't meet the
>>>>>>>>>>>>> requirements (which you can't change a be working on that problem)
>>>>>>>>>>>>
>>>>>>>>>>>> It might change this verdict, lets first see if it always works.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It CAN'T meet the requirements of a Halt Decider.
>>>>>>>>>>>
>>>>>>>>>>> That is proven.
>>>>>>>>>>
>>>>>>>>>> Let's just see if it can always decide undecidability.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Try to define that.
>>>>>>>>>
>>>>>>>>
>>>>>>>> What-ever term you want to call it the idea remains unchanged.
>>>>>>>> H(D,D) correctly determines that its input is pathological.
>>>>>>>>
>>>>>>>>> Undecidability is a property of the QUESTION or MAPPING, not the
>>>>>>>>> specific input.
>>>>>>>>
>>>>>>>
>>>>>>> If you can't actually define it, you can't say you have successfully
>>>>>>> detected it
>>>>>> Whenever an input calls its decider.
>>>>>>
>>>>>
>>>>> But in the real system it doesn't call "it's decider", it calls a copy
>>>>> of the decider that it was designed to confound.
>>>>
>>>> It needn't even be an exact copy. A camouflaged version would be as good.
>>>>
>>> There are certainly no limit to increasingly difficult cases.
>>> The cut-off on this is the original halting problem.
>>
>> There is no cut-off in the original halting problem. It is
>> about all Turing machines.
>>
>> But there is a related problem: if someone claims that some Turing machine
>> H is a halting decider, how could you test the claim?
>>
>
> All code is in C, thus tested against D().
>
> int D(int (*x)())
> {
> int Halt_Status = H(x, x);
> if (Halt_Status)
> HERE: goto HERE;
> return Halt_Status;
> }

On 2024-03-14 17:42:46 +0000, olcott said:

> On 3/14/2024 6:13 AM, Mikko wrote:
>> On 2024-03-13 19:51:07 +0000, olcott said:
>>
>>> On 3/13/2024 1:46 PM, Mikko wrote:
>>>> On 2024-03-13 05:40:24 +0000, olcott said:
>>>>
>>>>> On 3/12/2024 11:56 PM, Richard Damon wrote:
>>>>
>>>>>> The problem with trying to "Terminate Abnormally" and stopping any
>>>>>> machine using you is you then become not Turing Complete.
>>>>
>>>>> If any machine can do it, then it can be done. We can
>>>>> probably stick with the notion of a computation though:
>>>>> mapping inputs to outputs.
>>>>
>>>> If you want to terminate "abnoramlly" you must define a criterion
>>>> that differentiates an "abnormal" termination from a "normal"
>>>> termination.
>>>>
>>>> You can say "Xyzzy" but can you do it?
>>>>
>>>
>>> *Abnormal termination criteria*
>>> H(D,D) correctly determines that its input is calling itself
>>> with its same params in such a way that its input would never
>>> terminate unless aborted.
>>
>> After the termination, how do you determine whether T correctly
>> determined that its input is calling itself with its same params
>> in such a way that its input would neve terminate unless aborted?
>>
>
> There are no conditional branch instructions between the beginning
> of D and its call to H(D,D).

That doesn't prove that H determined that, let alone correctly.

--
Mikko

On 2024-03-14 20:52:57 +0000, olcott said:

> On 3/14/2024 6:37 AM, Mikko wrote:
>> On 2024-03-12 19:47:09 +0000, olcott said:
>>
>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't you working outside the premise
>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> I am working on the computability of the halting problem
>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> That is not "ecept", that is containted in what the word "Truring machine"
>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>>>>>>>>>>>>> everything your machine can, so your machine cannot compute anyting a
>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines and my C functions
>>>>>>>>>>>>> can always correctly report on the behavior of their actual input
>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>
>>>>>>>>>>>> If they only talk about themselves they are not useful.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> When every simulating halt decider reports on the actual behavior
>>>>>>>>>>> that it actually sees, then the pathological input does not
>>>>>>>>>>> thwart it.
>>>>>>>>>>
>>>>>>>>>> If it is not useful then nobody cares whether some input can thwart it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, that isn't what you asked,
>>>>>>>>
>>>>>>>> You asked if the CORRECT SIMULATION of the input won't stop, can H
>>>>>>>> abort its simlation.
>>>>>>>>
>>>>>>>> Of course, if H aborts it simulation, then BY DEFINITION, its
>>>>>>>> simulation doesn't go on forever and isn't a correct simulation, so
>>>>>>>> that doesn't apply.
>>>>>>>>
>>>>>>>
>>>>>>> It is your persistently repeated mistake that has been corrected
>>>>>>> hundreds of times that a correct simulation requires a complete
>>>>>>> simulation.
>>>>>>>
>>>>>>> The words that Professor Sipser agreed to clearly mean that
>>>>>>> when a correct partial simulation of D proves that a correct
>>>>>>> complete simulation of D would never stop running then H
>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>
>>>>>> Nope, because there is no such thing in Computation theory.
>>>>>>
>>>>>> Only in your incorrect reconstruction from lack of principles.
>>>>>>
>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of it.
>>>>>>
>>>>>
>>>>> "simulates its input D until"
>>>>> clearly does not mean simulate forever
>>>>>
>>>>
>>>> But you said:
>>>>
>>>> ... until H correctly determines that its simulated D would never stop
>>>> running unless aborted
>>>>
>>> The "until" clearly does not mean to simulate forever.
>>
>> But "would never stop" clearly does.
>>
>
> Only when you ignore the rest of the sentence.
> "simulated D would never stop running {unless aborted}

On 2024-03-15 00:01:52 +0000, olcott said:

> On 3/14/2024 5:21 PM, Richard Damon wrote:
>> On 3/14/24 2:49 PM, olcott wrote:
>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>
>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't you working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of the halting problem
>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in what the word "Truring machine"
>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>>>>>>>>>>>>>>>>> everything your machine can, so your machine cannot compute anyting a
>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines and my C functions
>>>>>>>>>>>>>>>>> can always correctly report on the behavior of their actual input
>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If they only talk about themselves they are not useful.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> When every simulating halt decider reports on the actual behavior
>>>>>>>>>>>>>>> that it actually sees, then the pathological input does not
>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> If it is not useful then nobody cares whether some input can thwart it.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>
>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input won't stop, can H
>>>>>>>>>>>> abort its simlation.
>>>>>>>>>>>>
>>>>>>>>>>>> Of course, if H aborts it simulation, then BY DEFINITION, its
>>>>>>>>>>>> simulation doesn't go on forever and isn't a correct simulation, so
>>>>>>>>>>>> that doesn't apply.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> It is your persistently repeated mistake that has been corrected
>>>>>>>>>>> hundreds of times that a correct simulation requires a complete
>>>>>>>>>>> simulation.
>>>>>>>>>>>
>>>>>>>>>>> The words that Professor Sipser agreed to clearly mean that
>>>>>>>>>>> when a correct partial simulation of D proves that a correct
>>>>>>>>>>> complete simulation of D would never stop running then H
>>>>>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>>>>>
>>>>>>>>>> Nope, because there is no such thing in Computation theory.
>>>>>>>>>>
>>>>>>>>>> Only in your incorrect reconstruction from lack of principles.
>>>>>>>>>>
>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> "simulates its input D until"
>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>
>>>>>>>>
>>>>>>>> But you said:
>>>>>>>>
>>>>>>>> ... until H correctly determines that its simulated D would never stop
>>>>>>>> running unless aborted
>>>>>>>>
>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>
>>>>>> But "would never stop" clearly does.
>>>>>>
>>>>>
>>>>> Only when you ignore the rest of the sentence.
>>>>> "simulated D would never stop running {unless aborted}
>>>>>
>>>>
>>>> But it DOES, The simulated D uses the H that is your final decison on
>>>> what H does, which will abort and return 0, so any correct simulation
>>>> of D will reach an end and stop running.
>>>>
>>>
>>> When we simply comment out the part where H aborts and then D(D)
>>> never stops this is proof that weasel words cannot actually thwart.
>>
>> Which means (by your constructio) that you changed D.
>>
>> You need D to still call the version that still had that abort in it.
>>
>
> Pathological Weasel words just don't work.

On 2024-03-15 02:34:18 +0000, immibis said:

> On 15/03/24 03:29, olcott wrote:
>>
>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>> *original criteria because it does meet the above criteria*
>>
>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (2) which begins at simulated ⟨Ĥ.q0⟩
>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>
>> The earliest point when Turing machine H can detect the repeating
>
> Whensoever H detects the repeating state and aborts it is incorrect
> because the state is not repeating. The state is repeating if H does
> not detect the repeating state.

It is not a repeating state at all. That 1 + 1 can be computed again and
again does not mean that 1 + 1 involves a loop. When H "detects" a
repeating state it actually detects that the state is entered the first
time by another coputation.

--
Mikko

On 2024-03-15 02:40:20 +0000, olcott said:

> On 3/14/2024 9:34 PM, immibis wrote:
>> On 15/03/24 03:29, olcott wrote:
>>>
>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>> *original criteria because it does meet the above criteria*
>>>
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> The earliest point when Turing machine H can detect the repeating
>>
>> Whensoever H detects the repeating state and aborts it is incorrect
>> because the state is not repeating. The state is repeating if H does
>> not detect the repeating state.
>
> 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.

Why not? It is true. One aborting is enough.

--
Mikko

On 2024-03-15 03:29:03 +0000, olcott said:

> On 3/14/2024 10:18 PM, Richard Damon wrote:
>> On 3/14/24 7:29 PM, olcott wrote:
>>> On 3/14/2024 9:08 PM, Richard Damon wrote:
>>>> On 3/14/24 6:02 PM, olcott wrote:
>>>>> On 3/14/2024 7:59 PM, Richard Damon wrote:
>>>>>> On 3/14/24 5:01 PM, olcott wrote:
>>>>>>> On 3/14/2024 5:21 PM, Richard Damon wrote:
>>>>>>>> On 3/14/24 2:49 PM, olcott wrote:
>>>>>>>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>>>>>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>>>>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't you working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of the halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a slightly augmented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> An important question to answer is whether a Turing machine can
>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD to the end
>>>>>>>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot be an Olcott machine.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in what the word "Truring machine"
>>>>>>>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation of your machine, compute
>>>>>>>>>>>>>>>>>>>>>>>> everything your machine can, so your machine cannot compute anyting a
>>>>>>>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines and my C functions
>>>>>>>>>>>>>>>>>>>>>>> can always correctly report on the behavior of their actual input
>>>>>>>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> If they only talk about themselves they are not useful.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> When every simulating halt decider reports on the actual behavior
>>>>>>>>>>>>>>>>>>>>> that it actually sees, then the pathological input does not
>>>>>>>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> If it is not useful then nobody cares whether some input can thwart it.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input won't stop, can H
>>>>>>>>>>>>>>>>>> abort its simlation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Of course, if H aborts it simulation, then BY DEFINITION, its
>>>>>>>>>>>>>>>>>> simulation doesn't go on forever and isn't a correct simulation, so
>>>>>>>>>>>>>>>>>> that doesn't apply.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is your persistently repeated mistake that has been corrected
>>>>>>>>>>>>>>>>> hundreds of times that a correct simulation requires a complete
>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> The words that Professor Sipser agreed to clearly mean that
>>>>>>>>>>>>>>>>> when a correct partial simulation of D proves that a correct
>>>>>>>>>>>>>>>>> complete simulation of D would never stop running then H
>>>>>>>>>>>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope, because there is no such thing in Computation theory.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Only in your incorrect reconstruction from lack of principles.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of it.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> "simulates its input D until"
>>>>>>>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But you said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ... until H correctly determines that its simulated D would never stop
>>>>>>>>>>>>>> running unless aborted
>>>>>>>>>>>>>>
>>>>>>>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>>>>>>>
>>>>>>>>>>>> But "would never stop" clearly does.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Only when you ignore the rest of the sentence.
>>>>>>>>>>> "simulated D would never stop running {unless aborted}
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But it DOES, The simulated D uses the H that is your final decison on
>>>>>>>>>> what H does, which will abort and return 0, so any correct simulation
>>>>>>>>>> of D will reach an end and stop running.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> When we simply comment out the part where H aborts and then D(D)
>>>>>>>>> never stops this is proof that weasel words cannot actually thwart.
>>>>>>>>
>>>>>>>> Which means (by your constructio) that you changed D.
>>>>>>>>
>>>>>>>> You need D to still call the version that still had that abort in it.
>>>>>>>>
>>>>>>>
>>>>>>> Pathological Weasel words just don't work.
>>>>>>>
>>>>>>> It is like you are saying that when someone goes back in time
>>>>>>> to kill Hitler so he does not murder six millions Jews this is
>>>>>>> proven to have never been needed when after they kill Hitler
>>>>>>> the six million Jews are never murdered.
>>>>>> Nope, Red Herring. Not the same. And the Time Travel introduces Paradox.
>>>>>>
>>>>>> It would be more like if your partner went back and killed Hitler, you
>>>>>> wouldn't need to go again yourself.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>>
>>>>>> Right, because THIS COPY of H doesn't, since the other copy DID.
>>>>>>
>>>>>> They are different machines (with the same algorithm), so different Identites.
>>>>>>
>>>>>
>>>>> Thus admitting that this criteria is met by H(D,D).
>>>>>
>>>>> 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.
>>>>>
>>>>>
>>>>
>>>> Nope.
>>>>
>>>> YOUR TOP Copy of H can't CORRECTLY DETERMINE that a correct simulation
>>>> of the input will be non-halting, because it Halts, since your H(D,D)
>>>> reteurn 0.
>>>>
>>>
>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>> *original criteria because it does meet the above criteria*
>>
>> The ONLY criteria is that the input (or a full complete simulation of
>> it) will not 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.

On 3/15/2024 4:36 AM, Fred. Zwarts wrote:
> Op 15.mrt.2024 om 03:40 schreef olcott:
>> On 3/14/2024 9:34 PM, immibis wrote:
>>> On 15/03/24 03:29, olcott wrote:
>>>>
>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>> *original criteria because it does meet the above criteria*
>>>>
>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> The earliest point when Turing machine H can detect the repeating
>>>
>>> Whensoever H detects the repeating state and aborts it is incorrect
>>> because the state is not repeating. The state is repeating if H does
>>> not detect the repeating state.
>>
>> 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.
>>
>
> Do you finally understand it? Hah(Dah,Dah) does not need to abort,
> because Dah halts. Hah should look at its input Dah (which aborts), not
> at its non-input Dss (which does not abort).

Unless some H(D,D) aborts the simulation of its input D(D) never stops
running. The outermost H(D,D) sees this abort criteria first. If the
outermost H(D,D) does not abort its simulation then none of them do.
therefore the outermost H(D,D) is correct to abort its simulation.

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

On 3/15/2024 7:23 AM, Mikko wrote:
> On 2024-03-15 03:29:03 +0000, olcott said:
>
>> On 3/14/2024 10:18 PM, Richard Damon wrote:
>>> On 3/14/24 7:29 PM, olcott wrote:
>>>> On 3/14/2024 9:08 PM, Richard Damon wrote:
>>>>> On 3/14/24 6:02 PM, olcott wrote:
>>>>>> On 3/14/2024 7:59 PM, Richard Damon wrote:
>>>>>>> On 3/14/24 5:01 PM, olcott wrote:
>>>>>>>> On 3/14/2024 5:21 PM, Richard Damon wrote:
>>>>>>>>> On 3/14/24 2:49 PM, olcott wrote:
>>>>>>>>>> On 3/14/2024 4:33 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/14/24 1:52 PM, olcott wrote:
>>>>>>>>>>>> On 3/14/2024 6:37 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Peaks said:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you working outside the premise
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pointed out.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> turing machines and what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> similar problems and proofs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> I am working on the computability of the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> halting problem
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> slightly augmented
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> below:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> An important question to answer is whether
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> a Turing machine can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a
>>>>>>>>>>>>>>>>>>>>>>>>>>>> UTM + TMD and one
>>>>>>>>>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform,
>>>>>>>>>>>>>>>>>>>>>>>>>>>> append the TMD to the end
>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot
>>>>>>>>>>>>>>>>>>>>>>>>>> be an Olcott machine.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> That is not "ecept", that is containted in what
>>>>>>>>>>>>>>>>>>>>>>>>> the word "Truring machine"
>>>>>>>>>>>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation
>>>>>>>>>>>>>>>>>>>>>>>>> of your machine, compute
>>>>>>>>>>>>>>>>>>>>>>>>> everything your machine can, so your machine
>>>>>>>>>>>>>>>>>>>>>>>>> cannot compute anyting a
>>>>>>>>>>>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines
>>>>>>>>>>>>>>>>>>>>>>>> and my C functions
>>>>>>>>>>>>>>>>>>>>>>>> can always correctly report on the behavior of
>>>>>>>>>>>>>>>>>>>>>>>> their actual input
>>>>>>>>>>>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> If they only talk about themselves they are not
>>>>>>>>>>>>>>>>>>>>>>> useful.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> When every simulating halt decider reports on the
>>>>>>>>>>>>>>>>>>>>>> actual behavior
>>>>>>>>>>>>>>>>>>>>>> that it actually sees, then the pathological input
>>>>>>>>>>>>>>>>>>>>>> does not
>>>>>>>>>>>>>>>>>>>>>> thwart it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> If it is not useful then nobody cares whether some
>>>>>>>>>>>>>>>>>>>>> input can thwart it.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You asked if the CORRECT SIMULATION of the input
>>>>>>>>>>>>>>>>>>> won't stop, can H abort its simlation.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Of course, if H aborts it simulation, then BY
>>>>>>>>>>>>>>>>>>> DEFINITION, its simulation doesn't go on forever and
>>>>>>>>>>>>>>>>>>> isn't a correct simulation, so that doesn't apply.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is your persistently repeated mistake that has been
>>>>>>>>>>>>>>>>>> corrected
>>>>>>>>>>>>>>>>>> hundreds of times that a correct simulation requires a
>>>>>>>>>>>>>>>>>> complete
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The words that Professor Sipser agreed to clearly mean
>>>>>>>>>>>>>>>>>> that
>>>>>>>>>>>>>>>>>> when a correct partial simulation of D proves that a
>>>>>>>>>>>>>>>>>> correct
>>>>>>>>>>>>>>>>>> complete simulation of D would never stop running then H
>>>>>>>>>>>>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Nope, because there is no such thing in Computation
>>>>>>>>>>>>>>>>> theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Only in your incorrect reconstruction from lack of
>>>>>>>>>>>>>>>>> principles.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of
>>>>>>>>>>>>>>>>> it.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> "simulates its input D until"
>>>>>>>>>>>>>>>> clearly does not mean simulate forever
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> But you said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> ... until H correctly determines that its simulated D
>>>>>>>>>>>>>>> would never stop running unless aborted
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The "until" clearly does not mean to simulate forever.
>>>>>>>>>>>>>
>>>>>>>>>>>>> But "would never stop" clearly does.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Only when you ignore the rest of the sentence.
>>>>>>>>>>>> "simulated D would never stop running {unless aborted}
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> But it DOES, The simulated D uses the H that is your final
>>>>>>>>>>> decison on what H does, which will abort and return 0, so any
>>>>>>>>>>> correct simulation of D will reach an end and stop running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> When we simply comment out the part where H aborts and then D(D)
>>>>>>>>>> never stops this is proof that weasel words cannot actually
>>>>>>>>>> thwart.
>>>>>>>>>
>>>>>>>>> Which means (by your constructio) that you changed D.
>>>>>>>>>
>>>>>>>>> You need D to still call the version that still had that abort
>>>>>>>>> in it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Pathological Weasel words just don't work.
>>>>>>>>
>>>>>>>> It is like you are saying that when someone goes back in time
>>>>>>>> to kill Hitler so he does not murder six millions Jews this is
>>>>>>>> proven to have never been needed when after they kill Hitler
>>>>>>>> the six million Jews are never murdered.
>>>>>>> Nope, Red Herring. Not the same. And the Time Travel introduces
>>>>>>> Paradox.
>>>>>>>
>>>>>>> It would be more like if your partner went back and killed
>>>>>>> Hitler, you wouldn't need to go again yourself.
>>>>>>>
>>>>>>>
>>>>>>>>
>>>>>>>> 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.
>>>>>>>>
>>>>>>>
>>>>>>> Right, because THIS COPY of H doesn't, since the other copy DID.
>>>>>>>
>>>>>>> They are different machines (with the same algorithm), so
>>>>>>> different Identites.
>>>>>>>
>>>>>>
>>>>>> Thus admitting that this criteria is met by H(D,D).
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>>
>>>>>
>>>>> Nope.
>>>>>
>>>>> YOUR TOP Copy of H can't CORRECTLY DETERMINE that a correct
>>>>> simulation of the input will be non-halting, because it Halts,
>>>>> since your H(D,D) reteurn 0.
>>>>>
>>>>
>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>> *original criteria because it does meet the above criteria*
>>>
>>> The ONLY criteria is that the input (or a full complete simulation of
>>> it) will not 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.
>
> I could keep saying the same, too. It is true.
>

On 3/15/2024 7:22 AM, Mikko wrote:
> On 2024-03-15 02:40:20 +0000, olcott said:
>
>> On 3/14/2024 9:34 PM, immibis wrote:
>>> On 15/03/24 03:29, olcott wrote:
>>>>
>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>> *original criteria because it does meet the above criteria*
>>>>
>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>
>>>> The earliest point when Turing machine H can detect the repeating
>>>
>>> Whensoever H detects the repeating state and aborts it is incorrect
>>> because the state is not repeating. The state is repeating if H does
>>> not detect the repeating state.
>>
>> 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.
>
> Why not? It is true. One aborting is enough.
>

Unless some H(D,D) aborts the simulation of its input D(D) never stops
running. The outermost H(D,D) sees this abort criteria first. If the
outermost H(D,D) does not abort its simulation then none of them do.
Therefore the outermost H(D,D) is correct to abort its simulation.

When the outermost H(D,D) aborts its simulation then the whole chain
is simulation is completely stopped.

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

On 3/15/2024 7:21 AM, Mikko wrote:
> On 2024-03-15 02:34:18 +0000, immibis said:
>
>> On 15/03/24 03:29, olcott wrote:
>>>
>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>> *original criteria because it does meet the above criteria*
>>>
>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>
>>> The earliest point when Turing machine H can detect the repeating
>>
>> Whensoever H detects the repeating state and aborts it is incorrect
>> because the state is not repeating. The state is repeating if H does
>> not detect the repeating state.
>
> It is not a repeating state at all. That 1 + 1 can be computed again and
> again does not mean that 1 + 1 involves a loop. When H "detects" a
> repeating state it actually detects that the state is entered the first
> time by another coputation.
>

Unless some H(D,D) aborts the simulation of its input D(D) never stops
running. The outermost H(D,D) sees this abort criteria first. If the
outermost H(D,D) does not abort its simulation then none of them do.
Therefore the outermost H(D,D) is correct to abort its simulation.

When the outermost H(D,D) aborts its simulation then the whole chain
is simulation is completely stopped.

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

On 3/15/2024 7:10 AM, Mikko wrote:
> On 2024-03-14 20:52:57 +0000, olcott said:
>
>> On 3/14/2024 6:37 AM, Mikko wrote:
>>> On 2024-03-12 19:47:09 +0000, olcott said:
>>>
>>>> On 3/12/2024 2:29 PM, Richard Damon wrote:
>>>>> On 3/12/24 12:16 PM, olcott wrote:
>>>>>> On 3/12/2024 1:58 PM, Richard Damon wrote:
>>>>>>> On 3/12/24 9:45 AM, olcott wrote:
>>>>>>>> On 3/12/2024 11:31 AM, Richard Damon wrote:
>>>>>>>>> On 3/12/24 7:02 AM, olcott wrote:
>>>>>>>>>> On 3/12/2024 3:49 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-11 15:34:04 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/11/2024 10:17 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-11 14:31:37 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/11/2024 4:51 AM, Mikko wrote:
>>>>>>>>>>>>>>> On 2024-03-10 14:29:20 +0000, olcott said:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On 3/10/2024 7:25 AM, Mikko wrote:
>>>>>>>>>>>>>>>>> On 2024-03-09 15:49:39 +0000, olcott said:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> On 3/9/2024 3:07 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>> On 2024-03-08 16:09:58 +0000, olcott said:
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> On 3/8/2024 9:29 AM, Mikko wrote:
>>>>>>>>>>>>>>>>>>>>> On 2024-03-08 05:23:34 +0000, Yaxley Peaks said:
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> With all of these extra frills, aren't you working
>>>>>>>>>>>>>>>>>>>>>> outside the premise
>>>>>>>>>>>>>>>>>>>>>> of the halting problem? Like how Andre pointed out.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes, he is.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> The halting problem concerns itself with turing
>>>>>>>>>>>>>>>>>>>>>> machines and what you
>>>>>>>>>>>>>>>>>>>>>> propose is not a turing machine.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> That is true. However, we can formulate similar
>>>>>>>>>>>>>>>>>>>>> problems and proofs
>>>>>>>>>>>>>>>>>>>>> for other classes of machines.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> I am working on the computability of the halting
>>>>>>>>>>>>>>>>>>>> problem
>>>>>>>>>>>>>>>>>>>> (the exact same TMD / input pairs) by a slightly
>>>>>>>>>>>>>>>>>>>> augmented
>>>>>>>>>>>>>>>>>>>> notion of Turing machines as elaborated below:
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM +
>>>>>>>>>>>>>>>>>>>> TMD and one
>>>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the
>>>>>>>>>>>>>>>>>>>> TMD to the
>>>>>>>>>>>>>>>>>>>> end of its own tape.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> An important question to answer is whether a Turing
>>>>>>>>>>>>>>>>>>> machine can
>>>>>>>>>>>>>>>>>>> simulate your machines.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Olcott machines are entirely comprised of a UTM + TMD
>>>>>>>>>>>>>>>>>> and one
>>>>>>>>>>>>>>>>>> extra step that any UTM could perform, append the TMD
>>>>>>>>>>>>>>>>>> to the end
>>>>>>>>>>>>>>>>>> of its own tape.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then a Turing machine can simulate your machine.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, except the TM doing the simulating cannot be an
>>>>>>>>>>>>>>>> Olcott machine.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is not "ecept", that is containted in what the word
>>>>>>>>>>>>>>> "Truring machine"
>>>>>>>>>>>>>>> means.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Anway, a Truing machine can, with a simulation of your
>>>>>>>>>>>>>>> machine, compute
>>>>>>>>>>>>>>> everything your machine can, so your machine cannot
>>>>>>>>>>>>>>> compute anyting a
>>>>>>>>>>>>>>> Turing machine cannot.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Turing Machines, Olcott Machines, RASP machines and my C
>>>>>>>>>>>>>> functions
>>>>>>>>>>>>>> can always correctly report on the behavior of their
>>>>>>>>>>>>>> actual input
>>>>>>>>>>>>>> When they report on this question:
>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>
>>>>>>>>>>>>> If they only talk about themselves they are not useful.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> When every simulating halt decider reports on the actual
>>>>>>>>>>>> behavior
>>>>>>>>>>>> that it actually sees, then the pathological input does not
>>>>>>>>>>>> thwart it.
>>>>>>>>>>>
>>>>>>>>>>> If it is not useful then nobody cares whether some input can
>>>>>>>>>>> thwart it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> 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 this criteria* (elaborated above)
>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>> *Then the halting problem is solved*
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> No, that isn't what you asked,
>>>>>>>>>
>>>>>>>>> You asked if the CORRECT SIMULATION of the input won't stop,
>>>>>>>>> can H abort its simlation.
>>>>>>>>>
>>>>>>>>> Of course, if H aborts it simulation, then BY DEFINITION, its
>>>>>>>>> simulation doesn't go on forever and isn't a correct
>>>>>>>>> simulation, so that doesn't apply.
>>>>>>>>>
>>>>>>>>
>>>>>>>> It is your persistently repeated mistake that has been corrected
>>>>>>>> hundreds of times that a correct simulation requires a complete
>>>>>>>> simulation.
>>>>>>>>
>>>>>>>> The words that Professor Sipser agreed to clearly mean that
>>>>>>>> when a correct partial simulation of D proves that a correct
>>>>>>>> complete simulation of D would never stop running then H
>>>>>>>> has both its abort criteria and its halt status criteria.
>>>>>>>
>>>>>>> Nope, because there is no such thing in Computation theory.
>>>>>>>
>>>>>>> Only in your incorrect reconstruction from lack of principles.
>>>>>>>
>>>>>>> You didn't say "PARTIAL", so he wasn't even thinking of it.
>>>>>>>
>>>>>>
>>>>>> "simulates its input D until"
>>>>>> clearly does not mean simulate forever
>>>>>>
>>>>>
>>>>> But you said:
>>>>>
>>>>> ... until H correctly determines that its simulated D would never
>>>>> stop running unless aborted
>>>>>
>>>> The "until" clearly does not mean to simulate forever.
>>>
>>> But "would never stop" clearly does.
>>>
>>
>> Only when you ignore the rest of the sentence.
>> "simulated D would never stop running {unless aborted}
>
> Wrong. In that context "would never stop" refers to endless simulation.
> Otherwise there would be no need to abort.
>

On 3/15/2024 6:58 AM, Mikko wrote:
> On 2024-03-14 17:42:46 +0000, olcott said:
>
>> On 3/14/2024 6:13 AM, Mikko wrote:
>>> On 2024-03-13 19:51:07 +0000, olcott said:
>>>
>>>> On 3/13/2024 1:46 PM, Mikko wrote:
>>>>> On 2024-03-13 05:40:24 +0000, olcott said:
>>>>>
>>>>>> On 3/12/2024 11:56 PM, Richard Damon wrote:
>>>>>
>>>>>>> The problem with trying to "Terminate Abnormally" and stopping
>>>>>>> any machine using you is you then become not Turing Complete.
>>>>>
>>>>>> If any machine can do it, then it can be done. We can
>>>>>> probably stick with the notion of a computation though:
>>>>>> mapping inputs to outputs.
>>>>>
>>>>> If you want to terminate "abnoramlly" you must define a criterion
>>>>> that differentiates an "abnormal" termination from a "normal"
>>>>> termination.
>>>>>
>>>>> You can say "Xyzzy" but can you do it?
>>>>>
>>>>
>>>> *Abnormal termination criteria*
>>>> H(D,D) correctly determines that its input is calling itself
>>>> with its same params in such a way that its input would never
>>>> terminate unless aborted.
>>>
>>> After the termination, how do you determine whether T correctly
>>> determined that its input is calling itself with its same params
>>> in such a way that its input would neve terminate unless aborted?
>>>
>>
>> There are no conditional branch instructions between the beginning
>> of D and its call to H(D,D).
>
> That doesn't prove that H determined that, let alone correctly.
>

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

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

On 3/15/24 7:22 AM, olcott wrote:
> On 3/15/2024 7:22 AM, Mikko wrote:
>> On 2024-03-15 02:40:20 +0000, olcott said:
>>
>>> On 3/14/2024 9:34 PM, immibis wrote:
>>>> On 15/03/24 03:29, olcott wrote:
>>>>>
>>>>> *Actually it is the fact that the top H ⟨Ĥ⟩ ⟨Ĥ⟩ (not a copy) does*
>>>>> *get this correctly that proves that H ⟨Ĥ⟩ ⟨Ĥ⟩ does not meet the*
>>>>> *original criteria because it does meet the above criteria*
>>>>>
>>>>> Execution trace of H applied to ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>> (1) H applied ⟨Ĥ⟩ ⟨Ĥ⟩ simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (2) which begins at simulated ⟨Ĥ.q0⟩
>>>>> (a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
>>>>> (b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
>>>>> (c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
>>>>>
>>>>> The earliest point when Turing machine H can detect the repeating
>>>>
>>>> Whensoever H detects the repeating state and aborts it is incorrect
>>>> because the state is not repeating. The state is repeating if H does
>>>> not detect the repeating state.
>>>
>>> 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.
>>
>> Why not? It is true. One aborting is enough.
>>
>
> Unless some H(D,D) aborts the simulation of its input D(D) never stops
> running. The outermost H(D,D) sees this abort criteria first. If the
> outermost H(D,D) does not abort its simulation then none of them do.
> Therefore the outermost H(D,D) is correct to abort its simulation.
>
> When the outermost H(D,D) aborts its simulation then the whole chain
> is simulation is completely stopped.
>

Right, but it your question is if THIS, the outermost, H needs to abort.

Each instance is a seperate entity.

And, it can be impossible to prove the submachine in H^ is actually the
exact same algorithm as H. (sometimes you can, but not always).

You are putting John in jail for the crime his twin brother Jack did
thinking they are the same.

Remember, the identity of H in H^ is lost once you create the machine
and its description. NOTHING in the final tuple definition of H^
mentions H, so it can be an unknowable fact.

That means, that by your attempted definiton, the behavior of a input
depends not just on the input itself, but what you know of its
provenance, how it was made and got to you.

THAT is ILLOGICAL.

And NO, while the outermost H aborting it simulation stops the
SIMULATION of all the machines, it does not stop the machines themselves.

You are just proving you don't understand what you are talking about,
and are living in your world of Make Beleive.