On 3/20/2024 3:48 AM, Mikko wrote:
> On 2024-03-19 17:46:39 +0000, olcott said:
>
>> On 3/19/2024 4:00 AM, Mikko wrote:
>>> On 2024-03-18 20:56:38 +0000, Richard Damon said:
>>>
>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>> *We are only looking at this*
>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>> truth--]
>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>
>>>>>>>>> (a) If *simulating abort decider H* correctly simulates its
>>>>>>>>> input D until H correctly determines that its simulated D would
>>>>>>>>> never stop running unless aborted then
>>>>>>>>
>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>>>>
>>>>>>>
>>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>>> otherwise X is not a member of set Y.
>>>>>>>
>>>>>>
>>>>>> And what are you defining X and set Y to be?
>>>>>>
>>>>>> That seems to be your problem, you are listing TWO distinct sets,
>>>>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>>>>
>>>>>> You can't argue about an input built on a different decider tells
>>>>>> you anything about the input built on THIS decider.
>>>>>
>>>>> *This is what those naming conventions derive*
>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>> simulation
>>>>> to prevent D(D) from infinite execution that this proves that it never
>>>>> needed to abort its simulation because it can rely on the fact that it
>>>>> already aborted its simulation thus never needed to abort it.
>>>>>
>>>>
>>>> So, you can't define what you SET is defined as?
>>>>
>>>> If not, then how can you complain that I don't get the members right?
>>>>
>>>> That is just part of your deception.
>>>>
>>>> And, you seem to have a confusion about identities.
>>>>
>>>> The calling of H by D is a distinct computation from the H called by
>>>> main that is trying to simulate the input given to it
>>>>
>>>> After all D(D) is DEFINED to be a seperate Computation that H is
>>>> supposed to decide on.
>>>>
>>>> Seperate things are separate things,
>>>>
>>>>
>>>> THIS H didn't "already abort it", it was THAT OTHER H that did,
>>>>
>>>> Somethibg distinct from it.
>>>>
>>>> At a different level of "Simulation"
>>>>
>>>> You don't seem to understand that each level of simulation is
>>>> something distinct.
>>>>
>>>> Otherwise, when H abort, it would be aborting "itself" and thus stop
>>>> running.
>>>
>>> Actually, the criterion discussed here only aborts H called by D.
>>> Another
>>> criterion is needed if the loop at the end of D needs be aborted.
>>>
>>
>> *counter-factual* The H called by the directly executed D(D)
>> cannot be aborted because it is directly executed.
>>
>> The H called by the simulated D(D) is also never directly
>> aborted only the simulated D(D) that calls it is aborted.
>
> See message <utce7a$tuf4$1@dont-email.me>.
>

It is a verified fact that:
(a) No directly executed H or directly executed D is every aborted.
(b) H(D,D) always must abort the simulation of its input.

--
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/20/2024 3:43 AM, Mikko wrote:
> On 2024-03-19 17:54:00 +0000, olcott said:
>
>> On 3/19/2024 11:21 AM, Mikko wrote:
>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>
>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>
>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>> truth--]
>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If *simulating abort decider H* correctly simulates its
>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>> would never stop running unless aborted then
>>>>>>>>>>>
>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY
>>>>>>>>>>> DETERMINES that its D will never stop running, unless THIS H
>>>>>>>>>>> aborts it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>
>>>>>>>>> That seems to be your problem, you are listing TWO distinct
>>>>>>>>> sets, which hae two distinct set of Deciders and two distince
>>>>>>>>> to of inputs.
>>>>>>>>>
>>>>>>>>> You can't argue about an input built on a different decider
>>>>>>>>> tells you anything about the input built on THIS decider.
>>>>>>>>
>>>>>>>> *This is what those naming conventions derive*
>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>> simulation
>>>>>>>> to prevent D(D) from infinite execution that this proves that it
>>>>>>>> never
>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>> that it
>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>
>>>>>>>
>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>
>>>>>>
>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>
>>>>> Use of double quantifiers may be a little confusing as each D calls
>>>>> only one H.
>>>>>
>>>>
>>>> *Counter factual*
>>>> My syntax is intended to specify the universe of H/D pairs such that
>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>
>>> Then you should quantify over those pairs with a simgle quantifier.
>>>
>> That wold not allow H and D to vary independently.
>
> Because the first thing after the quantifiers is to remove this
> independency there is no need to allow it.
>
>>> Anyway, every pair has a different D.
>>
>> *I proved otherwise below*
>> In infinite number of different H
>> (all having a different number of NOP padding)
>> all operate on the exact same D.
>
> Above you said the opposite.
>
>> In infinite number of different D
>> (all having a different number of NOP padding)
>> are all input to the exact same H.
>
> Above you said the opposite.
>
>>>> That there can be multiple H for every unique D and multiple D for
>>>> every unique H becomes more obvious when understand that we can pad
>>>> either H or D with an arbitrary number of NOP opcodes.
>>>> https://en.wikipedia.org/wiki/NOP_(code)
>
> There can be multiple D for every H because D is a parameter to H.
> There cannot be multiple H for any D because H is not a parameter
> to D and only one H is included in D.
>
> Because the
>

For every combination of H/D pairs such that
(H(D,D) simulates its input and D calls H(D,D))
There can be
multiple finite strings of machine-code of D for a single H
and
multiple finite strings of machine-code of H for a single D.
The differences may simply be a different number of NOP padding.

--
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/20/2024 3:37 AM, Mikko wrote:
> On 2024-03-19 18:58:54 +0000, olcott said:
>
>> On 3/19/2024 1:31 PM, immibis wrote:
>>> On 19/03/24 19:23, olcott wrote:
>>>> On 3/19/2024 12:40 PM, immibis wrote:
>>>>> On 19/03/24 03:46, olcott wrote:
>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>
>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>
>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>
>>>>>>>>>> If you can't even understand that H is a correct abort decider
>>>>>>>>>> then
>>>>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>> abort problem.
>>>>>>>>
>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>> learn
>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>> deciders.
>>>>>>>
>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>>> solving the Olcott abort problem?
>>>>>>
>>>>>> *Here are the two key steps to that*
>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>> (2) The halting problem requires the correct answer to an
>>>>>> incorrect question thus must be redefined.
>>>>>>
>>>>>>
>>>>> Thus the halting problem is unsolvable -- abort deciders cannot be
>>>>> extended to solve the halting problem instead of just the abort
>>>>> problem.
>>>>
>>>> Undecidable decision problem instances that are isomorphic to
>>>> incorrect questions are tossed out as having an incorrect problem
>>>> specification. This is a generalization and simplification of
>>>> professor Hehner's and Stoddart's view.
>>>>
>>>> E C R Hehner. *Objective and Subjective Specifications*
>>>> WST Workshop on Termination, Oxford.  2018 July 18.
>>>> See https://www.cs.toronto.edu/~hehner/OSS.pdf
>>>>
>>>> Bill Stoddart. *The Halting Paradox*
>>>> 20 December 2017
>>>> https://arxiv.org/abs/1906.05340
>>>> arXiv:1906.05340 [cs.LO]
>>>
>>> who cares? they're still undecidable
>>>
>>
>> They are undecidable in the same way that this question is
>> undecidable: Is this sentence true or false: "What time is it?"
>> A correct answer to that question is logically impossible.
>
> A question never has a truth value. It is easy to see that
> "What time is it?" is a question (it starts with "What" and
> ends with a question mark), so it is just stupid to ask
> its truth value.
>

Is this sentence true or false: "This sentence is no true."

Can Carol correctly answer “no” to this [yes/no] question?
When posed to Carol A correct answer to that question instance
is logically impossible.

Does D(D) halt?
Is a different question when posed to H(D,D) than when posed
to H1(D,D) even though it has the exact same words.

H1(D,D) sees that D(D) halts H(D,D) sees that D(D) does not halt.
They are both reporting on what they actually see.

--
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/20/2024 3:24 AM, Mikko wrote:
> On 2024-03-19 18:15:42 +0000, olcott said:
>
>> On 3/19/2024 12:41 PM, immibis wrote:
>>> On 19/03/24 05:11, olcott wrote:
>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>
>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>
>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>
>>>>>>>>>> If you can't even understand that H is a correct abort decider
>>>>>>>>>> then
>>>>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>> abort problem.
>>>>>>>>
>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>> learn
>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>> deciders.
>>>>>>>
>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>>> solving the Olcott abort problem?
>>>>>>
>>>>>> *Here are the two key steps to that*
>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>> (2) The halting problem requires the correct answer to an
>>>>>> incorrect question thus must be redefined.
>>>>>>
>>>>>>
>>>>>
>>>>> But (2) is a LIE.
>>>>>
>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>
>>>>
>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>> such that YES is a correct answer from one entity
>>>> and YES is an incorrect answer from another entity
>>>> is an incorrect question when posed to this second entity.
>>>
>>> If Ĥ is your x86utm function D, then "yes" is the correct answer to
>>> all entities.
>>
>> *counter factual*
>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> What is true is true even when contradicted by a liar.
>

D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see.

It <is> the case that their input specifies recursive simulation
that must be aborted or D(D) and Ĥ ⟨Ĥ⟩ never stop running.

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

On 3/20/2024 3:21 AM, Mikko wrote:
> On 2024-03-19 18:03:48 +0000, olcott said:
>
>> On 3/19/2024 12:46 PM, immibis wrote:
>>> On 19/03/24 17:43, olcott wrote:
>>>> On 3/18/2024 11:31 PM, Richard Damon wrote:
>>>>> On 3/18/24 9:11 PM, olcott wrote:
>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>
>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>>>
>>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>>> decider then
>>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>>> prerequisite
>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>>>> abort problem.
>>>>>>>>>>
>>>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>>>> learn
>>>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>>>> deciders.
>>>>>>>>>
>>>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>>>> deciders so that it solves the halting problem instead of
>>>>>>>>> merely solving the Olcott abort problem?
>>>>>>>>
>>>>>>>> *Here are the two key steps to that*
>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>>> incorrect question thus must be redefined.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> But (2) is a LIE.
>>>>>>>
>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>
>>>>>>
>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>> such that YES is a correct answer from one entity
>>>>>> and YES is an incorrect answer from another entity
>>>>>> is an incorrect question when posed to this second entity.
>>>>>
>>>>> So, SHOW ME and ACTUAL H and H^ such that H (H^) (H^) says yess
>>>>> incorrectly while H1 (H^) (H^) says yes correctly?
>>>>>
>>>>
>>>> *You found a bug in my words* (I will start consistently reporting
>>>> this)
>>>>
>>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>>> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to
>>>> Halts(Ĥ ⟨Ĥ⟩)
>>>>
>>>> So we are back to both YES and NO are the wrong answer for every
>>>> element in this template:
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> All of the elements that reported NO had to abort their simulation
>>>> or they could not have reported NO thus have no corresponding YES
>>>> element that reports at all.
>>>>
>>>> All of the elements that took the YES path failed to report because
>>>> they either did not abort their simulation or got stuck in the infinite
>>>> loop thus have no corresponding NO element.
>>>>
>>>>
>>>>
>>>
>>> He asked for an actual H and Ĥ not a copy-pasta.
>>
>> Those are brand new words that address the glitch that Richard
>> found in the words he was responding to.
>>
>> *There is no corresponding Ĥ.H that gets the correct answer on the*
>> *same input by providing the opposite answer to this same input*
>> *Every machine the gets the correct answer is outside of the above set*
>
> For every input there is a partial (non-corresponding) halt decider
> that gets that input right.
>

When any decision problem has decider/input pairs that are
undecidable instances these decider/input pairs are isomorphic
to incorrect questions.

Is this sentence true or false: "What time is it?"
Is this sentence true or false: "This sentence is not true."

Can Carol correctly answer “no” to this [yes/no] question?
When posed to Carol A correct answer to that question instance
is logically impossible.

The discourse context of who is asked makes "no" an incorrect
answer from Carol and correct answer from anyone else.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question for every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

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

On 3/20/2024 3:15 AM, Mikko wrote:
> On 2024-03-20 03:00:33 +0000, olcott said:
>
>> On 3/19/2024 11:14 AM, Mikko wrote:
>>> On 2024-03-19 15:47:14 +0000, olcott said:
>>>
>>>> On 3/19/2024 3:39 AM, Mikko wrote:
>>>>> On 2024-03-18 23:02:18 +0000, olcott said:
>>>>>
>>>>>> On 3/18/2024 6:26 AM, Mikko wrote:
>>>>>>> On 2024-03-18 03:07:18 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does
>>>>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D
>>>>>>>>>>>>>>>>>>>>>>>> would never stop running
>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input
>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>
>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>
>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>
>>>>>>>>>>> You have just proven that H doesn't need abort its simulation
>>>>>>>>>>> and the abort decision is incorrect.
>>>>>>>>>>
>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>
>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>> never stops running.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>>>>>> with an H that aborts its simulation has had its actual halting
>>>>>>>>> status tested.
>>>>>>>>>
>>>>>>>>
>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
>>>>>>>> H(D,D) does not abort its simulation necessitates simulated D(D)
>>>>>>>> never stops running.
>>>>>>>
>>>>>>> You should restrict your H so that any H that simulates D(D) forever
>>>>>>> is excluded, as simulating forver makes it a non-decider.
>>>>>>>
>>>>>>
>>>>>> I do yet so far everyone says that they believe this is impossible
>>>>>> so I have to go back a few steps and prove that it is possible.
>>>>>
>>>>> In logic any well defined expressible condition is allowed, even
>>>>> one that is impossible to evaluate.
>>>>>
>>>>
>>>> That seems to be a mistake otherwise geometry without square circles is
>>>> incomplete.
>>>
>>> Geometry is incomplete anyway.
>>>
>>>>>>> Also, "implies" is better than "necessitates", and even better if
>>>>>>> you only use "and", "or", and "not".
>>>>>>
>>>>>> The truth table of implies shows that nonsense "implies" truth.
>>>>>> I discard that as nonsense and use the term "necessitates" instead.
>>>>>
>>>>> The truth table of "necessitates" does the same. But "and", "or", and
>>>>> "not" is more than enough, you don't need any preplacement of
>>>>> "implies".
>>>
>>>> {necessitates} is the binary version of the unary Modal operator
>>>
>>> As soon as you use modal logic you disable yourself from refuting
>>> any proof of computation theory as they are based on classical
>>> logic.
>>>
>>
>>
>> // ‘□’ for the modal operator ‘it is necessary that’
>> P □□ Q eliminates
>>
>> https://en.wikipedia.org/wiki/Principle_of_explosion
>
> Irrelevant in comp.theory.
>

On 3/20/2024 3:12 AM, Mikko wrote:
> On 2024-03-20 03:03:33 +0000, olcott said:
>
>> On 3/19/2024 11:03 AM, Mikko wrote:
>>> On 2024-03-18 22:50:54 +0000, olcott said:
>>>
>>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>>> On 2024-03-17 16:35:32 +0000, olcott said:
>>>>>
>>>>>> On 3/17/2024 11:09 AM, Mikko wrote:
>>>>>>> On 2024-03-17 13:53:03 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>>>>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation
>>>>>>>>>>>>>>>>>>>>>> textbooks:
>>>>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by
>>>>>>>>>>>>>>>>>>>>>> sipser*
>>>>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim
>>>>>>>>>>>>>>>>>>>>>> paragraph is correct*
>>>>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything
>>>>>>>>>>>>>>>>>>>>>> else in this paper)
>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly determines
>>>>>>>>>>>>>>>>>>>>>> that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly
>>>>>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========
>>>>>>>>>>>>>>>>>>>>>> =============
>>>>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push
>>>>>>>>>>>>>>>>>>>>>> ebp      ; begin main()
>>>>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call
>>>>>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored
>>>>>>>>>>>>>>>>>>>>>> at:113075
>>>>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push
>>>>>>>>>>>>>>>>>>>>>> ebp       ; enter D(D)
>>>>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov
>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push
>>>>>>>>>>>>>>>>>>>>>> eax       ; push D
>>>>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov
>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push
>>>>>>>>>>>>>>>>>>>>>> ecx       ; push D
>>>>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call
>>>>>>>>>>>>>>>>>>>>>> 00001522  ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being
>>>>>>>>>>>>>>>>>>>>>> called with its same inputs and there are no
>>>>>>>>>>>>>>>>>>>>>> conditional branch instructions between the
>>>>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the
>>>>>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop
>>>>>>>>>>>>>>>>>>>>> running because *ITS* H will abort *ITS* simulation
>>>>>>>>>>>>>>>>>>>>> and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to
>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has
>>>>>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be
>>>>>>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and
>>>>>>>>>>>>>>>>>>> then when it's convenient for you you think there is
>>>>>>>>>>>>>>>>>>> only one H(D,D). Why is that?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has
>>>>>>>>>>>>>>>>>> been met
>>>>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its
>>>>>>>>>>>>>>>>>> input or
>>>>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>>>>>>> investigated this.
>>>>>>>>>>>>>>>> Because every H has the exact same code, if the first
>>>>>>>>>>>>>>>> one to see that
>>>>>>>>>>>>>>>> the abort criteria has been met does not abort then none
>>>>>>>>>>>>>>>> of them abort.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the
>>>>>>>>>>>>>>> H that we started with.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> If you change the H used by D, you change the quesition
>>>>>>>>>>>>>>> being asked.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> We cannot reference the behavior of what D(D) does after
>>>>>>>>>>>>>> H(D,D)
>>>>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion
>>>>>>>>>>>>>> measure
>>>>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>>>
>>>>>>>>>>>>> Then you cannot prove that H is a halting decider, as that
>>>>>>>>>>>>> is what
>>>>>>>>>>>>> you need to reference in the proof.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>>>>>
>>>>>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>>>>>> and H never aborts its simulation.
>>>>>>>>>>>
>>>>>>>>>>> The set from wich such H could be chosen is so small that
>>>>>>>>>>> it is no surprise that any H that simulates D(D) to its
>>>>>>>>>>> termination is not in that set.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> As soon as we hit complete proof of this we can move on
>>>>>>>>>> to another point.
>>>>>>>>>
>>>>>>>>> A complete proof of what?
>>>>>>>>>
>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>
>>>>>>> It is possible that you don't find such proof.
>>>>>>>
>>>>>>
>>>>>> Been there done that many times.
>>>>>
>>>>> You have presented nothing that even looks like proof, let alone is.
>>>>>
>>>>
>>>> That you don't understand that this is proof does not
>>>> entail that it is not proof.
>>>
>>> Yes it does. I know how a proof looks.
>>>
>>> A proof is a non-empty sequence of sentences, each of which is either
>>> an axiom, a postulate, a hypothesis, an assumption, a definition, or
>>> a result of an application of a valid inference rule to earlier
>>> sentences
>>> in the same proof. The last sentence in proof is the conclusion of the
>>> proof.
>>>
>>
>> Can D correctly simulated by H terminate normally?
>> 01 int D(ptr x)  // ptr is pointer to int function
>> 02 {
>> 03   int Halt_Status = H(x, x);
>> 04   if (Halt_Status)
>> 05     HERE: goto HERE;
>> 06   return Halt_Status;
>> 07 }
>> 08
>> 09 void main()
>> 10 {
>> 11   H(D,D);
>> 12 }
>>
>> *Execution Trace*
>> Line 11: main() invokes H(D,D);
>>
>> *keeps repeating* (unless aborted)
>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>
>> *Simulation invariant*
>> D correctly simulated by H cannot possibly reach past its own line 03.
>>
>> All halt deciders must compute the mapping from the behavior that its
>> finite string specifies... D specifies that N to ∞ steps of D correctly
>> simulated by H cannot possibly reach the final state of D at line (6),
>> thus D specifies non-halting behavior.
>
> No, all halt deciders compute the mapping that the halt problem
> specifies.
>

On 3/20/24 9:34 AM, olcott wrote:
> On 3/20/2024 3:12 AM, Mikko wrote:
>> On 2024-03-20 03:03:33 +0000, olcott said:
>>
>>> On 3/19/2024 11:03 AM, Mikko wrote:
>>>> On 2024-03-18 22:50:54 +0000, olcott said:
>>>>
>>>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>>>> On 2024-03-17 16:35:32 +0000, olcott said:
>>>>>>
>>>>>>> On 3/17/2024 11:09 AM, Mikko wrote:
>>>>>>>> On 2024-03-17 13:53:03 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation
>>>>>>>>>>>>>>>>>>>>>>> textbooks:
>>>>>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD,
>>>>>>>>>>>>>>>>>>>>>>> by sipser*
>>>>>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this
>>>>>>>>>>>>>>>>>>>>>>> verbatim paragraph is correct*
>>>>>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything
>>>>>>>>>>>>>>>>>>>>>>> else in this paper)
>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>>>> simulates its input D until H correctly
>>>>>>>>>>>>>>>>>>>>>>> determines that its simulated D would never stop
>>>>>>>>>>>>>>>>>>>>>>> running unless aborted then
>>>>>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly
>>>>>>>>>>>>>>>>>>>>>>> report that D specifies a non-halting sequence of
>>>>>>>>>>>>>>>>>>>>>>> configurations.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated
>>>>>>>>>>>>>>>>>>>>>>> above)
>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========
>>>>>>>>>>>>>>>>>>>>>>> =============
>>>>>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push
>>>>>>>>>>>>>>>>>>>>>>> ebp      ; begin main()
>>>>>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov
>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>>>>>>> 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push
>>>>>>>>>>>>>>>>>>>>>>> 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call
>>>>>>>>>>>>>>>>>>>>>>> 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored
>>>>>>>>>>>>>>>>>>>>>>> at:113075
>>>>>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push
>>>>>>>>>>>>>>>>>>>>>>> ebp       ; enter D(D)
>>>>>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov
>>>>>>>>>>>>>>>>>>>>>>> ebp,esp
>>>>>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov
>>>>>>>>>>>>>>>>>>>>>>> eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push
>>>>>>>>>>>>>>>>>>>>>>> eax       ; push D
>>>>>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov
>>>>>>>>>>>>>>>>>>>>>>> ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push
>>>>>>>>>>>>>>>>>>>>>>> ecx       ; push D
>>>>>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call
>>>>>>>>>>>>>>>>>>>>>>> 00001522  ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to
>>>>>>>>>>>>>>>>>>>>>>> main()
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>> criteria*
>>>>>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being
>>>>>>>>>>>>>>>>>>>>>>> called with its same inputs and there are no
>>>>>>>>>>>>>>>>>>>>>>> conditional branch instructions between the
>>>>>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the
>>>>>>>>>>>>>>>>>>>>>> required (a), since the simulated D WILL stop
>>>>>>>>>>>>>>>>>>>>>> running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will
>>>>>>>>>>>>>>>>>>>>>> halt.
>>>>>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to
>>>>>>>>>>>>>>>>>>>>> abort the
>>>>>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has
>>>>>>>>>>>>>>>>>>>>> aborted the
>>>>>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be
>>>>>>>>>>>>>>>>>>>>> aborted.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and
>>>>>>>>>>>>>>>>>>>> then when it's convenient for you you think there is
>>>>>>>>>>>>>>>>>>>> only one H(D,D). Why is that?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has
>>>>>>>>>>>>>>>>>>> been met
>>>>>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its
>>>>>>>>>>>>>>>>>>> input or
>>>>>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I was baffled by this for three days when I first
>>>>>>>>>>>>>>>>> investigated this.
>>>>>>>>>>>>>>>>> Because every H has the exact same code, if the first
>>>>>>>>>>>>>>>>> one to see that
>>>>>>>>>>>>>>>>> the abort criteria has been met does not abort then
>>>>>>>>>>>>>>>>> none of them abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus you look at a strawman. A case where H isn't
>>>>>>>>>>>>>>>> the H that we started with.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you change the H used by D, you change the quesition
>>>>>>>>>>>>>>>> being asked.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We cannot reference the behavior of what D(D) does after
>>>>>>>>>>>>>>> H(D,D)
>>>>>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion
>>>>>>>>>>>>>>> measure
>>>>>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then you cannot prove that H is a halting decider, as that
>>>>>>>>>>>>>> is what
>>>>>>>>>>>>>> you need to reference in the proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>>>>>>> that H correctly determined that it had to abort the
>>>>>>>>>>>>> simulation
>>>>>>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>>>>>>> and H never aborts its simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> The set from wich such H could be chosen is so small that
>>>>>>>>>>>> it is no surprise that any H that simulates D(D) to its
>>>>>>>>>>>> termination is not in that set.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> As soon as we hit complete proof of this we can move on
>>>>>>>>>>> to another point.
>>>>>>>>>>
>>>>>>>>>> A complete proof of what?
>>>>>>>>>>
>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>
>>>>>>>> It is possible that you don't find such proof.
>>>>>>>>
>>>>>>>
>>>>>>> Been there done that many times.
>>>>>>
>>>>>> You have presented nothing that even looks like proof, let alone is.
>>>>>>
>>>>>
>>>>> That you don't understand that this is proof does not
>>>>> entail that it is not proof.
>>>>
>>>> Yes it does. I know how a proof looks.
>>>>
>>>> A proof is a non-empty sequence of sentences, each of which is either
>>>> an axiom, a postulate, a hypothesis, an assumption, a definition, or
>>>> a result of an application of a valid inference rule to earlier
>>>> sentences
>>>> in the same proof. The last sentence in proof is the conclusion of the
>>>> proof.
>>>>
>>>
>>> Can D correctly simulated by H terminate normally?
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> All halt deciders must compute the mapping from the behavior that its
>>> finite string specifies... D specifies that N to ∞ steps of D correctly
>>> simulated by H cannot possibly reach the final state of D at line (6),
>>> thus D specifies non-halting behavior.
>>
>> No, all halt deciders compute the mapping that the halt problem
>> specifies.
>>
>
> Yet when I provide a concrete example proving that I am correct
> all you have is dogma instead of reasoning.
>

On 3/19/24 11:47 AM, olcott wrote:
> On 3/19/2024 3:39 AM, Mikko wrote:
>> On 2024-03-18 23:02:18 +0000, olcott said:
>>
>>> On 3/18/2024 6:26 AM, Mikko wrote:
>>>> On 2024-03-18 03:07:18 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does
>>>>>>>>>>>>>>>>>>>>> not actually see.
>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement
>>>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly
>>>>>>>>>>>>>>>>>>>>> simulates its input D until
>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would
>>>>>>>>>>>>>>>>>>>>> never stop running
>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or
>>>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>>>> prevent
>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>
>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>
>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>
>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>
>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>
>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>>>> will not halt.
>>>>>>>>>>
>>>>>>>>> Yes that is correct.
>>>>>>>>
>>>>>>>> You have just proven that H doesn't need abort its simulation
>>>>>>>> and the abort decision is incorrect.
>>>>>>>
>>>>>>> The head games of a Troll.
>>>>>>>
>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>> never stops running.
>>>>>>>
>>>>>>
>>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>>> with an H that aborts its simulation has had its actual halting
>>>>>> status tested.
>>>>>>
>>>>>
>>>>> *That merely changes the wording of the same truism*
>>>>> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
>>>>> H(D,D) does not abort its simulation necessitates simulated D(D)
>>>>> never stops running.
>>>>
>>>> You should restrict your H so that any H that simulates D(D) forever
>>>> is excluded, as simulating forver makes it a non-decider.
>>>>
>>>
>>> I do yet so far everyone says that they believe this is impossible
>>> so I have to go back a few steps and prove that it is possible.
>>
>> In logic any well defined expressible condition is allowed, even
>> one that is impossible to evaluate.
>>
>
> That seems to be a mistake otherwise geometry without square circles is
> incomplete.
>
>>>> Also, "implies" is better than "necessitates", and even better if
>>>> you only use "and", "or", and "not".
>>>
>>> The truth table of implies shows that nonsense "implies" truth.
>>> I discard that as nonsense and use the term "necessitates" instead.
>>
>> The truth table of "necessitates" does the same. But "and", "or", and
>> "not" is more than enough, you don't need any preplacement of "implies".
>>
> {necessitates} is the binary version of the unary Modal operator
>
> ◇P ↔ ¬□¬P
> Possibly(P) <is> Not(Necessarily(Not(P)))
>
> □P ↔ ¬◇¬P
> Necessarily(P) <is> Not(Possibly(Not(P)))
>
> (The Moon is made from green cheese □□ five is an integer) is false.
>
>>> A deductive argument is said to be valid if and only if it takes a form
>>> that makes it impossible for the premises to be true and the conclusion
>>> nevertheless to be false. https://iep.utm.edu/val-snd/
>>
>> Premisses and conclusions as well as all intermediate steps of
>> a valid argument can be expressed with "and", "or", and "not"
>> without any other connectives.
>>
>>> Thus the false statement that the Moon is made from green cheese
>>> therefore there is a 2 trillion ton rainbow colored elephant in
>>> my living room right now is misconstrued as valid.
>>
>> No, an argument is either valid or invalid but the statement is
>> true or false.
>>
> It is valid with the implies operator and invalid with the
> binary_Necessarily operator: □□

On 3/19/24 3:30 PM, olcott wrote:
> On 3/19/2024 12:20 PM, Richard Damon wrote:
>> On 3/19/24 9:43 AM, olcott wrote:
>>> On 3/18/2024 11:31 PM, Richard Damon wrote:
>>>> On 3/18/24 9:11 PM, olcott wrote:
>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>
>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>> decider then
>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>> prerequisite
>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>>> abort problem.
>>>>>>>>>
>>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>>> learn
>>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>>> deciders.
>>>>>>>>
>>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>>>> solving the Olcott abort problem?
>>>>>>>
>>>>>>> *Here are the two key steps to that*
>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>> incorrect question thus must be redefined.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But (2) is a LIE.
>>>>>>
>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>
>>>>>
>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>> such that YES is a correct answer from one entity
>>>>> and YES is an incorrect answer from another entity
>>>>> is an incorrect question when posed to this second entity.
>>>>
>>>> So, SHOW ME and ACTUAL H and H^ such that H (H^) (H^) says yess
>>>> incorrectly while H1 (H^) (H^) says yes correctly?
>>>>
>>>
>>> *You found a bug in my words* (I will start consistently reporting this)
>>>
>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ
>>> ⟨Ĥ⟩)
>>
>> Right, but only because you restrict yourself to looking at the H^
>> based on you, and the two lines are different Hs looking at different
>> H^s.
>>
>> So, not a contradiction.
>> when we clarify the differences we get:
>>
>> H1.Ĥ1 ⟨Ĥ1⟩ ⟨Ĥ1⟩ says YES this does not correspond to Halts(Ĥ1 ⟨Ĥ1⟩)
>> H2.Ĥ2 ⟨Ĥ2⟩ ⟨Ĥ2⟩ says  NO this does not correspond to Halts(Ĥ2 ⟨Ĥ2⟩)
>>
>> since Halts(Ĥ1 ⟨Ĥ1⟩) != Halts(Ĥ2 ⟨Ĥ2⟩) this isn't a problem.
>>
>>>
>>> So we are back to both YES and NO are the wrong answer for every
>>> element in this template:
>>
>> Nope,
>> No was the right answer for H1, and YES was the right answer for H2
>>
>
> There is no H in the above template that provides an answer
> consistent with Halts(D,D) no matter what answer this H provides.

So?

That doesn't mean there wasn't a correct answer.

You seem to have a problem with understanding the meaning of a correct
answer to a question existing?

Just because YOU are incapable of giving the correct answer, doesn't
mean one doesn't exist, you might just be to stupid or refuse to say te
correct answer.

>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> All of the elements that reported NO had to abort their simulation
>>> or they could not have reported NO thus have no corresponding YES
>>> element that reports at all.
>>>
>>> All of the elements that took the YES path failed to report because
>>> they either did not abort their simulation or got stuck in the infinite
>>> loop thus have no corresponding NO element.
>>>
>>
>> In other words, you need to use broken logic to try to assert your lie.
>>
>> Yes, All the H1s needed to abort but didn't
>>
>> All the H2s needs to continue to sumulate but didn't
>>
>> So, all did the wrong thing.
>>
>
> There is no H in the above template that provides an answer
> consistent with Halts(D,D) no matter what answer this H provides.

So?

That doesn't mean there wasn't a correct answer.

You seem to have a problem with understanding the meaning of a correct
answer to a question existing?

Just because YOU are incapable of giving the correct answer, doesn't
mean one doesn't exist, you might just be to stupid or refuse to say te
correct answer.

>
> Because every H in the above template has whatever answer that it
> does provide contradicted. When you move outside of the set where
> every answer is contradicted this becomes the strawman deception.

No, because the set you setup defines isn't the actual question.

>
> Since you keep doing that it seems to not be an honest mistake.
> I will keep giving you the benefit of the ever reducing doubt.
>

What "Mistake".

Will you look at the ACTUAL QUESTION? It doesn't restrict which question
can be given to what decider?

You confuse the question with the proof that every decider has an input
that it can't correctly decide on.

On 3/19/24 2:03 PM, olcott wrote:
> On 3/19/2024 12:46 PM, immibis wrote:
>> On 19/03/24 17:43, olcott wrote:
>>> On 3/18/2024 11:31 PM, Richard Damon wrote:
>>>> On 3/18/24 9:11 PM, olcott wrote:
>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>
>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>> decider then
>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>> prerequisite
>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>>> abort problem.
>>>>>>>>>
>>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>>> learn
>>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>>> deciders.
>>>>>>>>
>>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>>>> solving the Olcott abort problem?
>>>>>>>
>>>>>>> *Here are the two key steps to that*
>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>> incorrect question thus must be redefined.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But (2) is a LIE.
>>>>>>
>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>
>>>>>
>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>> such that YES is a correct answer from one entity
>>>>> and YES is an incorrect answer from another entity
>>>>> is an incorrect question when posed to this second entity.
>>>>
>>>> So, SHOW ME and ACTUAL H and H^ such that H (H^) (H^) says yess
>>>> incorrectly while H1 (H^) (H^) says yes correctly?
>>>>
>>>
>>> *You found a bug in my words* (I will start consistently reporting this)
>>>
>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to Halts(Ĥ
>>> ⟨Ĥ⟩)
>>>
>>> So we are back to both YES and NO are the wrong answer for every
>>> element in this template:
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> All of the elements that reported NO had to abort their simulation
>>> or they could not have reported NO thus have no corresponding YES
>>> element that reports at all.
>>>
>>> All of the elements that took the YES path failed to report because
>>> they either did not abort their simulation or got stuck in the infinite
>>> loop thus have no corresponding NO element.
>>>
>>>
>>>
>>
>> He asked for an actual H and Ĥ not a copy-pasta.
>
> Those are brand new words that address the glitch that Richard
> found in the words he was responding to.
>
> *There is no corresponding Ĥ.H that gets the correct answer on the*
> *same input by providing the opposite answer to this same input*
> *Every machine the gets the correct answer is outside of the above set*
>

So?

That doesn't mean there wasn't a correct answer.

You seem to have a problem with understanding the meaning of a correct
answer to a question existing?

Just because YOU are incapable of giving the correct answer, doesn't
mean one doesn't exist, you might just be to stupid or refuse to say te
correct answer.

On 3/20/24 9:28 AM, olcott wrote:
> On 3/20/2024 3:21 AM, Mikko wrote:
>> On 2024-03-19 18:03:48 +0000, olcott said:
>>
>>> On 3/19/2024 12:46 PM, immibis wrote:
>>>> On 19/03/24 17:43, olcott wrote:
>>>>> On 3/18/2024 11:31 PM, Richard Damon wrote:
>>>>>> On 3/18/24 9:11 PM, olcott wrote:
>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells
>>>>>>>>>>>>>> whether the direct execution of its input would halt.
>>>>>>>>>>>>>
>>>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>>>> decider then
>>>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>>>> prerequisite
>>>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Strawman deception. It is the halting problem, not the
>>>>>>>>>>>> Olcott abort problem.
>>>>>>>>>>>
>>>>>>>>>>> You can learn calculus without the basis of algebra. You
>>>>>>>>>>> can't learn
>>>>>>>>>>> simulating halt deciders without the basis of simulating
>>>>>>>>>>> abort deciders.
>>>>>>>>>>
>>>>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>>>>> deciders so that it solves the halting problem instead of
>>>>>>>>>> merely solving the Olcott abort problem?
>>>>>>>>>
>>>>>>>>> *Here are the two key steps to that*
>>>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>>>> incorrect question thus must be redefined.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> But (2) is a LIE.
>>>>>>>>
>>>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>>>
>>>>>>>
>>>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>>>> such that YES is a correct answer from one entity
>>>>>>> and YES is an incorrect answer from another entity
>>>>>>> is an incorrect question when posed to this second entity.
>>>>>>
>>>>>> So, SHOW ME and ACTUAL H and H^ such that H (H^) (H^) says yess
>>>>>> incorrectly while H1 (H^) (H^) says yes correctly?
>>>>>>
>>>>>
>>>>> *You found a bug in my words* (I will start consistently reporting
>>>>> this)
>>>>>
>>>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says YES this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>>>> H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says  NO this does not correspond to Halts(Ĥ ⟨Ĥ⟩)
>>>>> No matter what any H.Ĥ ⟨Ĥ⟩ ⟨Ĥ⟩ says it does not correspond to
>>>>> Halts(Ĥ ⟨Ĥ⟩)
>>>>>
>>>>> So we are back to both YES and NO are the wrong answer for every
>>>>> element in this template:
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> All of the elements that reported NO had to abort their simulation
>>>>> or they could not have reported NO thus have no corresponding YES
>>>>> element that reports at all.
>>>>>
>>>>> All of the elements that took the YES path failed to report because
>>>>> they either did not abort their simulation or got stuck in the
>>>>> infinite
>>>>> loop thus have no corresponding NO element.
>>>>>
>>>>>
>>>>>
>>>>
>>>> He asked for an actual H and Ĥ not a copy-pasta.
>>>
>>> Those are brand new words that address the glitch that Richard
>>> found in the words he was responding to.
>>>
>>> *There is no corresponding Ĥ.H that gets the correct answer on the*
>>> *same input by providing the opposite answer to this same input*
>>> *Every machine the gets the correct answer is outside of the above set*
>>
>> For every input there is a partial (non-corresponding) halt decider
>> that gets that input right.
>>
>
> When any decision problem has decider/input pairs that are
> undecidable instances these decider/input pairs are isomorphic
> to incorrect questions.

Nope.

Just shows the problem is uncomputable (aka undecidable).

>
> Is this sentence true or false: "What time is it?"
> Is this sentence true or false: "This sentence is not true."
>

Different types of question, so just a strawman argument.

One of you favorite methods of arguing, perhaps because it is incorrect.

> Can Carol correctly answer “no” to this [yes/no] question?
> When posed to Carol A correct answer to that question instance
> is logically impossible.
>
> The discourse context of who is asked makes "no" an incorrect
> answer from Carol and correct answer from anyone else.

But Halting WOULD have been a correct answer from the H that happens to
answer Non-Halting, it is just the answer it didn't compute to give.

>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
> Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question for every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>

Nope.

Just proving you don't have the proper definition of a "correct
question", because you are just too stupid and ingornat of the topic.

On 3/19/24 3:04 PM, olcott wrote:
> On 3/19/2024 1:30 PM, immibis wrote:
>> On 19/03/24 19:15, olcott wrote:
>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>> On 19/03/24 05:11, olcott wrote:
>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>
>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>> decider then
>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>> prerequisite
>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>>> abort problem.
>>>>>>>>>
>>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>>> learn
>>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>>> deciders.
>>>>>>>>
>>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>>>> solving the Olcott abort problem?
>>>>>>>
>>>>>>> *Here are the two key steps to that*
>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>> incorrect question thus must be redefined.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But (2) is a LIE.
>>>>>>
>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>
>>>>>
>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>> such that YES is a correct answer from one entity
>>>>> and YES is an incorrect answer from another entity
>>>>> is an incorrect question when posed to this second entity.
>>>>
>>>> If Ĥ is your x86utm function D, then "yes" is the correct answer to
>>>> all entities.
>>>
>>> *counter factual*
>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> no it is not
>>
>> "yes" is the correct answer to all entities.
>
> An answer of YES causes both D(D) and Ĥ ⟨Ĥ⟩ to never halt.
>
>

But that H can't give the answer yes. You are hypothesizing and
impossible case.

Change the H, and you change the question.

That seems so foreign to you, because you don't actually understand what
truth and reality mean.

On 3/20/24 9:20 AM, olcott wrote:
> On 3/20/2024 3:24 AM, Mikko wrote:
>> On 2024-03-19 18:15:42 +0000, olcott said:
>>
>>> On 3/19/2024 12:41 PM, immibis wrote:
>>>> On 19/03/24 05:11, olcott wrote:
>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote:
>>>>>> On 3/18/24 7:46 PM, olcott wrote:
>>>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>>>
>>>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>>>
>>>>>>>>>>> If you can't even understand that H is a correct abort
>>>>>>>>>>> decider then
>>>>>>>>>>> you can't understand anything else that requires the
>>>>>>>>>>> prerequisite
>>>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>>>> abort problem.
>>>>>>>>>
>>>>>>>>> You can learn calculus without the basis of algebra. You can't
>>>>>>>>> learn
>>>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>>>> deciders.
>>>>>>>>
>>>>>>>> When are you going to extend this theory of simulating abort
>>>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>>>> solving the Olcott abort problem?
>>>>>>>
>>>>>>> *Here are the two key steps to that*
>>>>>>> (1) Abort deciders correctly decide to abort.
>>>>>>> (2) The halting problem requires the correct answer to an
>>>>>>> incorrect question thus must be redefined.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> But (2) is a LIE.
>>>>>>
>>>>>> There is nothing "Incorrect" about the Halting Question.
>>>>>>
>>>>>
>>>>> Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
>>>>> such that YES is a correct answer from one entity
>>>>> and YES is an incorrect answer from another entity
>>>>> is an incorrect question when posed to this second entity.
>>>>
>>>> If Ĥ is your x86utm function D, then "yes" is the correct answer to
>>>> all entities.
>>>
>>> *counter factual*
>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> What is true is true even when contradicted by a liar.
>>
>
> D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
> correctly reporting on what they actually see.
>
> It <is> the case that their input specifies recursive simulation
> that must be aborted or D(D) and Ĥ ⟨Ĥ⟩ never stop running.
>

Nope. They think they see what they think they see because they were
built with fault logic. Apparently you are actually unable to understand
what "Correct Reasoning" would be.

They are incorrect, just as all your arguing has been incorrect. YOU see
though distorted lens that just can't understand what is actual reality.

On 3/19/24 11:19 PM, olcott wrote:
> On 3/19/2024 10:52 AM, Richard Damon wrote:
>> On 3/19/24 8:34 AM, olcott wrote:
>>> On 3/19/2024 3:45 AM, Mikko wrote:
>>>> On 2024-03-19 02:46:27 +0000, olcott said:
>>>>
>>>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>>>> On 19/03/24 00:43, olcott wrote:
>>>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or
>>>>>>>>>>>>> fail to abort?
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>>>
>>>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>>>
>>>>>>>>>> Strawman deception. H is a halt decider if it tells whether
>>>>>>>>>> the direct execution of its input would halt.
>>>>>>>>>
>>>>>>>>> If you can't even understand that H is a correct abort decider
>>>>>>>>> then
>>>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>>>> abort problem.
>>>>>>>
>>>>>>> You can learn calculus without the basis of algebra. You can't learn
>>>>>>> simulating halt deciders without the basis of simulating abort
>>>>>>> deciders.
>>>>>>
>>>>>> When are you going to extend this theory of simulating abort
>>>>>> deciders so that it solves the halting problem instead of merely
>>>>>> solving the Olcott abort problem?
>>>>>
>>>>> *Here are the two key steps to that*
>>>>> (1) Abort deciders correctly decide to abort.
>>>>> (2) The halting problem requires the correct answer to an incorrect
>>>>> question thus must be redefined.
>>>>
>>>> If a problem is redefined it must also be renamed. The original name
>>>> is already reserved.
>>>>
>>>
>>> OK then when H(D,D) reports on the actual behavior of its actual
>>> input this is called the corrected halting problem. The original
>>> halting problem is now called the erroneous halting problem.
>>> We can call it the Naive halting problem like ZFC did to set theory.
>>>
>>> Alternatively H(D,D) can reject inputs that must be aborted because
>>> these inputs specify a pathological relationship to their decider.
>>>
>>
>> Except that your H doesn't report on the ACTUAL BEHAVIOR of its input,
>> because that behavior is what the computation described by the input
>> does.
>>
>
> *The computation described by the input does not halt*

But it DOES if H returns 0, which you admit your H does.

> *The computation described by the input does not halt*
> *The computation described by the input does not halt*
>
> Can D correctly simulated by H terminate normally?

Wrong QUESTION, so a Strawman.

Only applies if H DOES correctly simulate its input, INVALID quesiton if
H aborts it, as it has no basis to have an answer, thus is invalid oby
the false presumption that H does correct simulate its input.

> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)

But since H DOES abort its simulation, this is an UNSOUND arguement, as
it is based on a FALSE premise.

>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.

Only if H never aborts its simulation

>
> All halt deciders must compute the mapping from the behavior that its
> finite string specifies... D specifies that N to ∞ steps of D correctly
> simulated by H cannot possibly reach the final state of D at line (6),
> thus D specifies non-halting behavior.
>

Nope.. *THIS* D doesn't specify that, as it is based on a SPECIFIC H
that does abort at a SPECIFIC time, and thus D WILL return after that
amount of time.

You are just proving that you don't understand the concept of a
deterministic program.

You just don't understand the foundations of Computation Theory, because
you don't understand what a Computation is, likely because you lied to
yourself about what it was in your zeroth principles that don't include
that actual principles of the problem space.

On 3/19/24 3:10 PM, olcott wrote:
> On 3/19/2024 1:23 PM, immibis wrote:
>> On 19/03/24 18:54, olcott wrote:
>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>> Then you should quantify over those pairs with a simgle quantifier.
>>>>
>>> That wold not allow H and D to vary independently.
>>
>> Don't you keep saying that you are only interested in the D which
>> calls H?
>>
>>>
>>>> Anyway, every pair has a different D.
>>>>
>>>
>>> *I proved otherwise below*
>>> In infinite number of different H
>>> (all having a different number of NOP padding)
>>> all operate on the exact same D.
>>>
>>> In infinite number of different D
>>> (all having a different number of NOP padding)
>>> are all input to the exact same H.
>>
>> Nobody is arguing on the basis of NOPs, and it's still true that every
>> pair has a different D. Adding NOPs to a D does not change which H is
>> called by that D.
>>
>>>>> That there can be multiple H for every unique D and multiple D for
>>>>> every unique H becomes more obvious when understand that we can pad
>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>
>> There can only be one H for each D. Changing the H also changes the D
>> because D is considered as a complete self-contained program.
>>
>
> A single D can have an infinite number of different H
> as long as they are all at the same machine address,
> and (H(D,D) simulates its input and D calls H(D,D)).
>
>

Nope.

Not when you describe D as a TMD.

A TMD is a Turing Machine Description, which means, BY DEFINITION, it
has ALL the algorithm that it will use included, INCLUDING that of the H
it uses a copy of.

You are just proving your stupidity.

The fact you keep going back to these statements is why you are stuck
using Turing Machine compatible definitions for yoru terms, you are
ADMITITNG that you are trying (but failing) to make your system a Turing
Equivalent of the Halting Problem and its proof.

On 3/20/24 9:09 AM, olcott wrote:
> On 3/20/2024 3:43 AM, Mikko wrote:
>> On 2024-03-19 17:54:00 +0000, olcott said:
>>
>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>
>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>
>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>>> truth--]
>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly simulates its
>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>> would never stop running unless aborted then
>>>>>>>>>>>>
>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY
>>>>>>>>>>>> DETERMINES that its D will never stop running, unless THIS H
>>>>>>>>>>>> aborts it.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>
>>>>>>>>>> That seems to be your problem, you are listing TWO distinct
>>>>>>>>>> sets, which hae two distinct set of Deciders and two distince
>>>>>>>>>> to of inputs.
>>>>>>>>>>
>>>>>>>>>> You can't argue about an input built on a different decider
>>>>>>>>>> tells you anything about the input built on THIS decider.
>>>>>>>>>
>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>> simulation
>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>> it never
>>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>>> that it
>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>
>>>>>>>
>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>
>>>>>> Use of double quantifiers may be a little confusing as each D calls
>>>>>> only one H.
>>>>>>
>>>>>
>>>>> *Counter factual*
>>>>> My syntax is intended to specify the universe of H/D pairs such that
>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>
>>>> Then you should quantify over those pairs with a simgle quantifier.
>>>>
>>> That wold not allow H and D to vary independently.
>>
>> Because the first thing after the quantifiers is to remove this
>> independency there is no need to allow it.
>>
>>>> Anyway, every pair has a different D.
>>>
>>> *I proved otherwise below*
>>> In infinite number of different H
>>> (all having a different number of NOP padding)
>>> all operate on the exact same D.
>>
>> Above you said the opposite.
>>
>>> In infinite number of different D
>>> (all having a different number of NOP padding)
>>> are all input to the exact same H.
>>
>> Above you said the opposite.
>>
>>>>> That there can be multiple H for every unique D and multiple D for
>>>>> every unique H becomes more obvious when understand that we can pad
>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>
>> There can be multiple D for every H because D is a parameter to H.
>> There cannot be multiple H for any D because H is not a parameter
>> to D and only one H is included in D.
>>
>> Because the
>>
>
> For every combination of H/D pairs such that
> (H(D,D) simulates its input and D calls H(D,D))
> There can be
> multiple finite strings of machine-code of D for a single H
> and
> multiple finite strings of machine-code of H for a single D.
> The differences may simply be a different number of NOP padding.
>

Yes, a given D might "call" any of a number of different (but are
EQUIVALENT) Hs. But no "H" that isn't EQUIVALENT to those (Equivalent
means gives the exact same output for the exact same inputs)

But your wildly different Hs that your first select over give many
different equivalency classes, and a given D only is paired with one.

On 3/19/24 11:06 PM, olcott wrote:
> On 3/19/2024 10:59 AM, Richard Damon wrote:
>> On 3/19/24 8:23 AM, olcott wrote:
>>> On 3/19/2024 3:54 AM, Fred. Zwarts wrote:
>>>> Op 18.mrt.2024 om 23:49 schreef olcott:
>>>>> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>>>>>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>>>>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated D would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of D until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can be encoded and D(D) calls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, the we get a non-haltig
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoded and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>> no D that was built with an H that aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation has had its actual halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> status tested.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only
>>>>>>>>>>>>>>>>>>>>>>>>> two sets*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in
>>>>>>>>>>>>>>>>>>>>>>>> set (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop
>>>>>>>>>>>>>>>>>>>>>>>> running, and thus the top level H didn't need to
>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you
>>>>>>>>>>>>>>>>>>>>> don't understand
>>>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set
>>>>>>>>>>>>>>>>>>>>> and X not being
>>>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the
>>>>>>>>>>>>>>>>>>>> H that it was designed to confound.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of
>>>>>>>>>>>>>>> (2) is correct*
>>>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect
>>>>>>>>>>>>>>> is incorrect*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>>>> the Han that does not meet its abort criteria does
>>>>>>>>>>>>>>>> abort. So, both are wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort
>>>>>>>>>>>>> its simulation
>>>>>>>>>>>>> to prevent D(D) from infinite execution that this proves
>>>>>>>>>>>>> that it never
>>>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>>>> fact that it
>>>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are almost there. If you stop naming all different H
>>>>>>>>>>>> which the same name and all different D with the same name,
>>>>>>>>>>>> your confusion may disappear.
>>>>>>>>>>>
>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>> H(D,D))
>>>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>>>
>>>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and the
>>>>>>>>>>>> Han
>>>>>>>>>>>> that does not meet its abort criteria does abort. So, both
>>>>>>>>>>>> are wrong.
>>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>>>
>>>>>>>>> *You are confused*
>>>>>>>>> If the H in the simulated D aborts then the directly executed H
>>>>>>>>> did
>>>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>>>> aborts.
>>>>>>>>>
>>>>>>>>
>>>>>>>> No, Olcott told us that the simulating H aborts before it sees
>>>>>>>> that the simulated D halts. It only sees that D calls H, but it
>>>>>>>> does not see that the called H aborts, because the simulation
>>>>>>>> stops at the call, which is too early.
>>>>>>>>
>>>>>>>
>>>>>>> DD correctly simulated by HH cannot possibly reach past its
>>>>>>> own first line, thus cannot possibly halt.
>>>>>>
>>>>>> Olcott does not understand that if the call to HH were correctly
>>>>>> simulated, then this HH would abort its simulation and return and
>>>>>> therefore DD would continue
>>>>>
>>>>> *When HH aborts its simulation DD immediately becomes 100%
>>>>> totally dead along with the entire simulation chain. I don't
>>>>> think that Richard understands this either.
>>>>>
>>>>
>>>> Olcott does not understand that we are talking about a DD that
>>>> contains a HH that aborts. He is constructing a problem, that does
>>>> not exists,
>>>
>>> It is fully operational code, thus physically exists.
>>
>> And proves that you don't understand what it is telling you.
>>
>> DD(DD) Halts, so HH(DD,DD) saying it doesn't is WRONG.
>>
>>>
>>>> because he names all programs with the same names. This causes his
>>>> confusion. His DD is the Dan, which is based on Han. When changing
>>>> the decider from Han to Hss, we should still consider the same Dan.
>>>> But in his mind this can only be done by also changing Dan into Dss.
>>>> He is unable to see that Han(Dan,Dan) does not need to abort, but it
>>>> does and Hss(Dss,Dss) needs to abort, but it doesn't. Han and Hss
>>>> are different deciders. Dan and Dss are different programs. So, we
>>>> cannot talk about them with the same name. He seems to understand
>>>> that both Han(Dan,Dan) and Hss(Dss,Dss) are wrong, but by assuming
>>>> that Dan and Dss are equivalent, he thinks that it is right to claim
>>>> that Han(Dan,Dan) is still correct. He seems to be unable to see
>>>> that Dan and Dss are not equivalent. It is impossible to talk about
>>>> them as if they were the same programs.
>>>>
>>>
>>> The following is true for every element of the set no matter how
>>> these elements are named. If naming them somehow makes it seem that
>>> any of these elements do not have their stipulated property then
>>> naming causes misconception.
>>>
>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>> When H(D,D) does not abort its simulation then
>>> this causes the simulated D(D) to never stop running.
>>>
>>
>> Right, so those elements of  ∀D ∈ TMD that are based on a H that
>> doesn't abort its simulation are non-halting, but none of those H's
>> will ever say that.
>>
>> Only invalid logic would try to say that this in any way shows that
>> the Ds based on Hs that DO abort their simulation are also
>> non-halting, or that the H simulating them NEEDS to abort it
>> simulation to reach an end state.
>
> *You can Diss and Hiss yet not correctly refute this*
> *You can Diss and Hiss yet not correctly refute this*
> *You can Diss and Hiss yet not correctly refute this*

On 2024-03-20 13:34:01 +0000, olcott said:

> On 3/20/2024 3:12 AM, Mikko wrote:
>> On 2024-03-20 03:03:33 +0000, olcott said:
>>
>>> On 3/19/2024 11:03 AM, Mikko wrote:
>>>> On 2024-03-18 22:50:54 +0000, olcott said:
>>>>
>>>>> On 3/18/2024 5:49 AM, Mikko wrote:
>>>>>> On 2024-03-17 16:35:32 +0000, olcott said:
>>>>>>
>>>>>>> On 3/17/2024 11:09 AM, Mikko wrote:
>>>>>>>> On 2024-03-17 13:53:03 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>>>>>   ========  ========  ========  ========= =============
>>>>>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>>>>>>>>>>>>>>>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the
>>>>>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>>>>>>>>>>>>>>>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> I was baffled by this for three days when I first investigated this.
>>>>>>>>>>>>>>>>> Because every H has the exact same code, if the first one to see that
>>>>>>>>>>>>>>>>> the abort criteria has been met does not abort then none of them abort.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H that we
>>>>>>>>>>>>>>>> started with.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> If you change the H used by D, you change the quesition being asked.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>>>>>>>> you need to reference in the proof.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>>>>>>
>>>>>>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>>>>>>> and H never aborts its simulation.
>>>>>>>>>>>>
>>>>>>>>>>>> The set from wich such H could be chosen is so small that
>>>>>>>>>>>> it is no surprise that any H that simulates D(D) to its
>>>>>>>>>>>> termination is not in that set.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> As soon as we hit complete proof of this we can move on
>>>>>>>>>>> to another point.
>>>>>>>>>>
>>>>>>>>>> A complete proof of what?
>>>>>>>>>>
>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>
>>>>>>>> It is possible that you don't find such proof.
>>>>>>>>
>>>>>>>
>>>>>>> Been there done that many times.
>>>>>>
>>>>>> You have presented nothing that even looks like proof, let alone is.
>>>>>>
>>>>>
>>>>> That you don't understand that this is proof does not
>>>>> entail that it is not proof.
>>>>
>>>> Yes it does. I know how a proof looks.
>>>>
>>>> A proof is a non-empty sequence of sentences, each of which is either
>>>> an axiom, a postulate, a hypothesis, an assumption, a definition, or
>>>> a result of an application of a valid inference rule to earlier sentences
>>>> in the same proof. The last sentence in proof is the conclusion of the
>>>> proof.
>>>>
>>>
>>> Can D correctly simulated by H terminate normally?
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> All halt deciders must compute the mapping from the behavior that its
>>> finite string specifies... D specifies that N to ∞ steps of D correctly
>>> simulated by H cannot possibly reach the final state of D at line (6),
>>> thus D specifies non-halting behavior.
>>
>> No, all halt deciders compute the mapping that the halt problem
>> specifies.
>>
>
> Yet when I provide a concrete example proving that I am correct
> all you have is dogma instead of reasoning.

On 2024-03-20 13:32:03 +0000, olcott said:

> On 3/20/2024 3:15 AM, Mikko wrote:
>> On 2024-03-20 03:00:33 +0000, olcott said:
>>
>>> On 3/19/2024 11:14 AM, Mikko wrote:
>>>> On 2024-03-19 15:47:14 +0000, olcott said:
>>>>
>>>>> On 3/19/2024 3:39 AM, Mikko wrote:
>>>>>> On 2024-03-18 23:02:18 +0000, olcott said:
>>>>>>
>>>>>>> On 3/18/2024 6:26 AM, Mikko wrote:
>>>>>>>> On 2024-03-18 03:07:18 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove what you
>>>>>>>>>>>>>>>>>>>>>> need it to.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig D(D), but H
>>>>>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>>>>>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>
>>>>>>>>>>>> You have just proven that H doesn't need abort its simulation and the
>>>>>>>>>>>> abort decision is incorrect.
>>>>>>>>>>>
>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>
>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>> never stops running.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was built with an
>>>>>>>>>> H that aborts its simulation has had its actual halting status tested.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
>>>>>>>>> H(D,D) does not abort its simulation necessitates simulated D(D)
>>>>>>>>> never stops running.
>>>>>>>>
>>>>>>>> You should restrict your H so that any H that simulates D(D) forever
>>>>>>>> is excluded, as simulating forver makes it a non-decider.
>>>>>>>>
>>>>>>>
>>>>>>> I do yet so far everyone says that they believe this is impossible
>>>>>>> so I have to go back a few steps and prove that it is possible.
>>>>>>
>>>>>> In logic any well defined expressible condition is allowed, even
>>>>>> one that is impossible to evaluate.
>>>>>>
>>>>>
>>>>> That seems to be a mistake otherwise geometry without square circles is
>>>>> incomplete.
>>>>
>>>> Geometry is incomplete anyway.
>>>>
>>>>>>>> Also, "implies" is better than "necessitates", and even better if
>>>>>>>> you only use "and", "or", and "not".
>>>>>>>
>>>>>>> The truth table of implies shows that nonsense "implies" truth.
>>>>>>> I discard that as nonsense and use the term "necessitates" instead.
>>>>>>
>>>>>> The truth table of "necessitates" does the same. But "and", "or", and
>>>>>> "not" is more than enough, you don't need any preplacement of "implies".
>>>>
>>>>> {necessitates} is the binary version of the unary Modal operator
>>>>
>>>> As soon as you use modal logic you disable yourself from refuting
>>>> any proof of computation theory as they are based on classical
>>>> logic.
>>>>
>>>
>>>
>>> // ‘□’ for the modal operator ‘it is necessary that’
>>> P □□ Q eliminates
>>>
>>> https://en.wikipedia.org/wiki/Principle_of_explosion
>>
>> Irrelevant in comp.theory.
>>
>
> *Here is how it is relevant*
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt
> When Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ reports on the behavior of its input: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ □□ Ĥ.Hqn

On 3/19/24 3:02 PM, olcott wrote:
> On 3/19/2024 1:51 PM, immibis wrote:
>> On 19/03/24 09:54, Fred. Zwarts wrote:
>>>
>>> Olcott does not understand that we are talking about a DD that
>>> contains a HH that aborts. He is constructing a problem, that does
>>> not exists, because he names all programs with the same names. This
>>> causes his confusion. His DD is the Dan, which is based on Han. When
>>> changing the decider from Han to Hss, we should still consider the
>>> same Dan. But in his mind this can only be done by also changing Dan
>>> into Dss. He is unable to see that Han(Dan,Dan) does not need to
>>> abort, but it does and Hss(Dss,Dss) needs to abort, but it doesn't.
>>> Han and Hss are different deciders. Dan and Dss are different
>>> programs. So, we cannot talk about them with the same name. He seems
>>> to understand that both Han(Dan,Dan) and Hss(Dss,Dss) are wrong, but
>>> by assuming that Dan and Dss are equivalent, he thinks that it is
>>> right to claim that Han(Dan,Dan) is still correct. He seems to be
>>> unable to see that Dan and Dss are not equivalent. It is impossible
>>> to talk about them as if they were the same programs.
>>>
>>
>> It may be that he does not understand this, or it may be that he
>> thinks Dan(Dan) does not halt unless aborted even though it is obvious
>> that Dan(Dan) does halt unless aborted.
>
>
> main() { D(D); } never halts unless another instance of itself is
> aborted. Because this other instance must be aborted that proves
> that it specifies a non-halting sequence of configurations.
>

No

The question is about THIS instance.

You don't understand what instances mean, because you are just ignorant
of the topic.

And your refusal to learn, shows you are just self-made stupid.

On 3/19/24 2:07 PM, olcott wrote:
> On 3/19/2024 10:37 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 15:56 schreef olcott:
>>> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>>>> Op 19.mrt.2024 om 05:37 schreef olcott:
>>>>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>>>>> On 3/18/24 8:53 PM, olcott wrote:
>>>>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) If simulating halt
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decider H correctly simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input D until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly determines that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulated D would never
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> stop running
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *H correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> partial simulation of D until
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> can be encoded and D(D) calls
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort, the we get a non-haltig
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> subject away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> to abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> decision is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> encoded and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so
>>>>>>>>>>>>>>>>>>>>>>>>>>>> no D that was built with an H that aborts
>>>>>>>>>>>>>>>>>>>>>>>>>>>> its simulation has had its actual halting
>>>>>>>>>>>>>>>>>>>>>>>>>>>> status tested.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only
>>>>>>>>>>>>>>>>>>>>>>>>> two sets*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in
>>>>>>>>>>>>>>>>>>>>>>>> set (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop
>>>>>>>>>>>>>>>>>>>>>>>> running, and thus the top level H didn't need to
>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you
>>>>>>>>>>>>>>>>>>>>> don't understand
>>>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set
>>>>>>>>>>>>>>>>>>>>> and X not being
>>>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the
>>>>>>>>>>>>>>>>>>>> H that it was designed to confound.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of
>>>>>>>>>>>>>>> (2) is correct*
>>>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect
>>>>>>>>>>>>>>> is incorrect*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>>>> the Han that does not meet its abort criteria does
>>>>>>>>>>>>>>>> abort. So, both are wrong.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort
>>>>>>>>>>>>> its simulation
>>>>>>>>>>>>> to prevent D(D) from infinite execution that this proves
>>>>>>>>>>>>> that it never
>>>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>>>> fact that it
>>>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> You are almost there. If you stop naming all different H
>>>>>>>>>>>> which the same name and all different D with the same name,
>>>>>>>>>>>> your confusion may disappear.
>>>>>>>>>>>
>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>> H(D,D))
>>>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>>>
>>>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and the
>>>>>>>>>>>> Han
>>>>>>>>>>>> that does not meet its abort criteria does abort. So, both
>>>>>>>>>>>> are wrong.
>>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>>>
>>>>>>>>> *You are confused*
>>>>>>>>> If the H in the simulated D aborts then the directly executed H
>>>>>>>>> did
>>>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>>>> aborts.
>>>>>>>>
>>>>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>>>>
>>>>>>> Then a dozen square circles are on sale at Walmart right now for
>>>>>>> $10.99
>>>>>>
>>>>>> Interesting, that you retort was to just blantently lie?
>>>>>>
>>>>>> When presented with FACTS, you respond with LIES.
>>>>>>
>>>>>> That just shows who you are.
>>>>>>
>>>>>>>
>>>>>>>> then the directly executed D MUST abort, or you are agreeing
>>>>>>>> that H's simulation is not correct.
>>>>>>>>
>>>>>>>
>>>>>>> In other words after we have been over this hundreds and hundreds
>>>>>>> of times it is still waaaayyy over your head that the executed H
>>>>>>> always
>>>>>>> sees exactly one more execution trace than the executed H?
>>>>>>
>>>>>> Do you really read your nonsense?
>>>>>>
>>>>>> How does x, "the executed H" see one more execution trace than x?
>>>>>>
>>>>>> That means you think that 1 + 1 = 1
>>>>>>
>>>>>>>
>>>>>>>> And no, the directed executed vesion of D see no more
>>>>>>>> information then the machine the simulated D represents,
>>>>>>>
>>>>>>> The simulated H can not see its own behavior where as its simulator
>>>>>>> can thus proving the simulator sees one more execution trace that
>>>>>>> its simulation.
>>>>>>
>>>>>> Nope, it may see one more then at the point the simulation reaches,
>>>>>
>>>>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>>>>> any of the simulated ones ever would.
>>>>>
>>>>>> but the actual machine that is now being simulated did EVERYTHING
>>>>>> that it will do as soon as it was created,
>>>>>>
>>>>> No it is not true that x86 machines are oracle machines.
>>>>> https://en.wikipedia.org/wiki/Oracle_machine
>>>>>
>>>>>> You keep on makeing that mistake, confusing the simulation with
>>>>>> what actually happens.
>>>>>>
>>>>>>>
>>>>>>>> if H aborts the simulation before then, then H just doesn't get
>>>>>>>> to know what happens after that.
>>>>>>>>
>>>>>>>> I will point out, you almost NEVER actually look at the direct
>>>>>>>> execution of D(D), because it just proves that H isn't a correct
>>>>>>>> Halt Decider.
>>>>>>>>
>>>>>>>
>>>>>>> H(D,D) cannot rely on the behavior of D(D) after it has already
>>>>>>> aborted
>>>>>>> its simulation or it would never abort its simulation and D(D) would
>>>>>>> never stop running. This means that the executed H(D,D) see non
>>>>>>> halting
>>>>>>> behavior.
>>>>>>>
>>>>>>
>>>>>> Right, H is in a no-win pickle. (or its programmer is).
>>>>>
>>>>> Not at all. The requirement for clairvoyance is an incorrect
>>>>> requirement. H(D,D) cannot be correctly required to report on
>>>>> what it cannot see.
>>>>>
>>>>>> If we wait, we run into the issue that we may never answer. If we
>>>>>> abort, we don't know what answer to give.
>>>>>
>>>>> An abort decider would report on whether it aborted or not.
>>>>>
>>>>>> That is why the Halting Mapping turns out to be uncomputable.
>>>>>>
>>>>>
>>>>> *H(D,D) cannot be correctly required to report on what it cannot see*
>>>>>
>>>>
>>>> But H(D,D) cannot be allowed to choose what it want to see and what
>>>> it does not want to see. By aborting, it chooses to close it eyes
>>>> and therefore it does not see that D calls H, which aborts and
>>>> returns. It is not a matter of 'cannot see', but 'chooses to be
>>>> blind for the facts'.
>>>>
>>>
>>> Can D correctly simulated by H terminate normally?
>>> 01 int D(ptr x)  // ptr is pointer to int function
>>> 02 {
>>> 03   int Halt_Status = H(x, x);
>>> 04   if (Halt_Status)
>>> 05     HERE: goto HERE;
>>> 06   return Halt_Status;
>>> 07 }
>>> 08
>>> 09 void main()
>>> 10 {
>>> 11   H(D,D);
>>> 12 }
>>>
>>> *Execution Trace*
>>> Line 11: main() invokes H(D,D);
>>>
>>> *keeps repeating* (unless aborted)
>>> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>>>
>>> *Simulation invariant*
>>> D correctly simulated by H cannot possibly reach past its own line 03.
>>>
>>> H: Begin Simulation   Execution Trace Stored at:113075
>>> Address_of_H:1522
>>>
>>>   machine   stack     stack     machine    assembly
>>>   address   address   data      code       language
>>>   ========  ========  ========  =========  =============
>>> [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()
>>>
>>> It is the case that the simulated D(D) can't possibly reach its
>>> final instruction and terminate normally, thus can't possibly halt.
>>>
>>> Unless H(D,D) sees that its input can't possibly halt and aborts
>>> its simulation on that basis then the executed D(D) also never halts.
>>>
>>
>> Olcott keeps naming all different H and D with the same name. This is
>> very confusing. Maybe he himself is the most confused one. He seems to
>> think that Dan is equivalent to Dss, so that he can claim both: that
>> it can keep running and halts. So that it both needs to be aborted and
>> halts of its own after aborting its simulation.
>> If he only would use appropriate naming, so that we know whether he is
>> talking about Dss or Dan, then he himself could also be freed from his
>> confusion.
>> It is an easily verified fact that Dan can reach past its own line 03,
>> but Dss cannot. But Dss does not abort, so the corresponding Hss does
>> not halt. He seems to be very confused.
>
> No D correctly simulated by any H(D,D) such that D calls H(D,D)
> can possibly reach past its own line 03.
>
> Every attempt to rebut this has always been the strawman deception
> of changing to a different set of H/D pairs.
>

On 2024-03-20 12:52:24 +0000, olcott said:

> On 3/20/2024 3:59 AM, Mikko wrote:
>> On 2024-03-19 17:48:14 +0000, olcott said:
>>
>>> On 3/19/2024 11:33 AM, Mikko wrote:
>>>> On 2024-03-19 14:35:03 +0000, olcott said:
>>>>
>>>>> On 3/19/2024 4:37 AM, Mikko wrote:
>>>>>> On 2024-03-18 23:05:33 +0000, olcott said:
>>>>>>
>>>>>>> On 3/18/2024 6:43 AM, Mikko wrote:
>>>>>>>> On 2024-03-17 23:47:01 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/17/2024 2:45 PM, Richard Damon wrote:
>>>>>>>>>> On 3/17/24 9:31 AM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>>>>>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>>>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its input D until
>>>>>>>>>>>>>>>>> H correctly determines that its simulated D would never stop running
>>>>>>>>>>>>>>>>> unless aborted then
>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp ; begin main()
>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp ; enter D(D)
>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax ; push D
>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx ; push D
>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>>>>>>>>>>>>> the same.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>>>>>>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>>>>>>>>>>> what it meets instead.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> The requirement is not specifically about behaviour that the decider
>>>>>>>>>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>>>>>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>>>>>>>>>> meet the specification in all cases.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>>>>>>>>>
>>>>>>>>>>>> But cannot meet its specification.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> First we must come to mutual agreement that H(D,D) is correct
>>>>>>>>>>> to abort its simulation.
>>>>>>>>>>
>>>>>>>>>> Which means we need to first come to an aggreement of what that means.
>>>>>>>>>>
>>>>>>>>>> You DID agree earlier to this:
>>>>>>>>>>
>>>>>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>>>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>>>>>>>>
>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>> never stops running.
>>>>>>>>
>>>>>>>> That is ambiguous: does D(D) call H(D,D) if H is encoded in another way
>>>>>>>> than the one that D(D) calls?
>>>>>>>>
>>>>>>>
>>>>>>> I have no idea what you are meaning.
>>>>>>> It is assumed that H and D are C functions.
>>>>>>
>>>>>> What exacly you don't understand? Do you understand the following
>>>>>> phrases:
>>>>>>
>>>>>> - "every possibe way that H can be encoded" ?
>>>>>>
>>>>>> - "D(D) calls H(D,D)" ?
>>>>>>
>>>>>> - "the H(D,D) that D(D) calls" ?
>>>>>>
>>>>>> - "H(D,D) aborts its simulation"
>>>>>>
>>>>>> Unless you can answer I can only assume that you are too stupid
>>>>>> for this discussion.
>>>>>>
>>>>>
>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>>>>> stops running.
>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>
>>>> Seems the best I can do is to assume.
>>>>
>>>
>>> It seems to me that I fully answered your question
>>> thus no assumptions are required.
>>
>> What were the answers?
>>
>
> *The computation described by the input does not halt*
> *The computation described by the input does not halt*
> *The computation described by the input does not halt*
>
> Can D correctly simulated by H terminate normally?
> 01 int D(ptr x) // ptr is pointer to int function
> 02 {
> 03 int Halt_Status = H(x, x);
> 04 if (Halt_Status)
> 05 HERE: goto HERE;
> 06 return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11 H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>
> All halt deciders must compute the mapping from the behavior that its
> finite string specifies... D specifies that N to ∞ steps of D correctly
> simulated by H cannot possibly reach the final state of D at line (6),
> thus D specifies non-halting behavior.

On 2024-03-20 13:09:15 +0000, olcott said:

> On 3/20/2024 3:43 AM, Mikko wrote:
>> On 2024-03-19 17:54:00 +0000, olcott said:
>>
>>> On 3/19/2024 11:21 AM, Mikko wrote:
>>>> On 2024-03-19 15:06:05 +0000, olcott said:
>>>>
>>>>> On 3/19/2024 4:05 AM, Mikko wrote:
>>>>>> On 2024-03-18 21:16:42 +0000, olcott said:
>>>>>>
>>>>>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If *simulating abort decider H* correctly simulates its input D
>>>>>>>>>>>>> until H correctly determines that its simulated D would never stop
>>>>>>>>>>>>> running unless aborted then
>>>>>>>>>>>>
>>>>>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES that
>>>>>>>>>>>> its D will never stop running, unless THIS H aborts it.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>>>>>>> otherwise X is not a member of set Y.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> And what are you defining X and set Y to be?
>>>>>>>>>>
>>>>>>>>>> That seems to be your problem, you are listing TWO distinct sets, which
>>>>>>>>>> hae two distinct set of Deciders and two distince to of inputs.
>>>>>>>>>>
>>>>>>>>>> You can't argue about an input built on a different decider tells you
>>>>>>>>>> anything about the input built on THIS decider.
>>>>>>>>>
>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>>>>>>>> to prevent D(D) from infinite execution that this proves that it never
>>>>>>>>> needed to abort its simulation because it can rely on the fact that it
>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>
>>>>>>>>
>>>>>>>> So, you can't define what you SET is defined as?
>>>>>>>>
>>>>>>>
>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>
>>>>>> Use of double quantifiers may be a little confusing as each D calls
>>>>>> only one H.
>>>>>>
>>>>>
>>>>> *Counter factual*
>>>>> My syntax is intended to specify the universe of H/D pairs such that
>>>>> (H(D,D) simulates its input and D calls H(D,D))
>>>>
>>>> Then you should quantify over those pairs with a simgle quantifier.
>>>>
>>> That wold not allow H and D to vary independently.
>>
>> Because the first thing after the quantifiers is to remove this
>> independency there is no need to allow it.
>>
>>>> Anyway, every pair has a different D.
>>>
>>> *I proved otherwise below*
>>> In infinite number of different H
>>> (all having a different number of NOP padding)
>>> all operate on the exact same D.
>>
>> Above you said the opposite.
>>
>>> In infinite number of different D
>>> (all having a different number of NOP padding)
>>> are all input to the exact same H.
>>
>> Above you said the opposite.
>>
>>>>> That there can be multiple H for every unique D and multiple D for
>>>>> every unique H becomes more obvious when understand that we can pad
>>>>> either H or D with an arbitrary number of NOP opcodes.
>>>>> https://en.wikipedia.org/wiki/NOP_(code)
>>
>> There can be multiple D for every H because D is a parameter to H.
>> There cannot be multiple H for any D because H is not a parameter
>> to D and only one H is included in D.
>
> For every combination of H/D pairs such that
> (H(D,D) simulates its input and D calls H(D,D))
> There can be
> multiple finite strings of machine-code of D for a single H
> and
> multiple finite strings of machine-code of H for a single D.
> The differences may simply be a different number of NOP padding.

D calls only one H.

--
Mikko

On 3/19/2024 4:37 AM, Mikko wrote:
> On 2024-03-18 23:05:33 +0000, olcott said:
>
>> On 3/18/2024 6:43 AM, Mikko wrote:
>>> On 2024-03-17 23:47:01 +0000, olcott said:
>>>
>>>> On 3/17/2024 2:45 PM, Richard Damon wrote:
>>>>> On 3/17/24 9:31 AM, olcott wrote:
>>>>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>
>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph
>>>>>>>>>>>> is correct*
>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this
>>>>>>>>>>>> paper)
>>>>>>>>>>>> (a) If simulating halt decider H correctly simulates its
>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>> would never stop running unless aborted then
>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report
>>>>>>>>>>>> that D specifies a non-halting sequence of configurations.
>>>>>>>>>>>>
>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ;
>>>>>>>>>>>> begin main()
>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>> push DD
>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>> push D
>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ;
>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>>
>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ;
>>>>>>>>>>>> enter D(D)
>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ;
>>>>>>>>>>>> push D
>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ;
>>>>>>>>>>>> push D
>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ;
>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>
>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with
>>>>>>>>>>>> its same inputs and there are no conditional branch
>>>>>>>>>>>> instructions between the invocation of D(D) and its call to
>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>
>>>>>>>>>>> This proof is not simpler or more convinceing than earlier
>>>>>>>>>>> proofs of
>>>>>>>>>>> the same.
>>>>>>>>>>>
>>>>>>>>>>> It is also as uninteresting as the proved claim. As long as H
>>>>>>>>>>> does
>>>>>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>>>>>> what it meets instead.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>> that H(D,D) must report on behavior that it does not actually
>>>>>>>>>> see.
>>>>>>>>>
>>>>>>>>> The requirement is not specifically about behaviour that the
>>>>>>>>> decider
>>>>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>>>>> meet the specification in all cases.
>>>>>>>>>
>>>>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>>>>
>>>>>>> But cannot meet its specification.
>>>>>>>
>>>>>>
>>>>>> First we must come to mutual agreement that H(D,D) is correct
>>>>>> to abort its simulation.
>>>>>
>>>>> Which means we need to first come to an aggreement of what that means.
>>>>>
>>>>> You DID agree earlier to this:
>>>>>
>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>>> halt.
>>>>>>>
>>>>>> Yes that is correct.
>>>>>>
>>>>>
>>>>
>>>> For every possible way that H can be encoded and D(D)
>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>> never stops running.
>>>
>>> That is ambiguous: does D(D) call H(D,D) if H is encoded in another way
>>> than the one that D(D) calls?
>>>
>>
>> I have no idea what you are meaning.
>> It is assumed that H and D are C functions.
>
> What exacly you don't understand? Do you understand the following
> phrases:
>
> - "every possibe way that H can be encoded" ?
>
> - "D(D) calls H(D,D)" ?
>
> - "the H(D,D) that D(D) calls" ?
>
> - "H(D,D) aborts its simulation"
>