On 3/20/2024 7:50 PM, Richard Damon wrote:
> On 3/20/24 6:50 PM, olcott wrote:
>> On 3/20/2024 5:40 PM, immibis wrote:
>>> On 20/03/24 22:49, olcott wrote:
>>>> On 3/20/2024 4:42 PM, Richard Damon wrote:
>>>>> On 3/19/24 2:15 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>
>>>>> How is that.
>>>>>
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>>
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>>>>
>>>
>>> Those are different Ĥ.
>>
>> The question is always: Does Ĥ ⟨Ĥ⟩ halt?
>
> And H always gets it wrong, and every H^ has a H that gets it wrong.
>

There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ in the above set that get it right
and every TM that gets it right is not in the above set.

--
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/24 8:59 PM, olcott wrote:
> On 3/20/2024 7:50 PM, Richard Damon wrote:
>> On 3/20/24 6:50 PM, olcott wrote:
>>> On 3/20/2024 5:40 PM, immibis wrote:
>>>> On 20/03/24 22:49, olcott wrote:
>>>>> On 3/20/2024 4:42 PM, Richard Damon wrote:
>>>>>> On 3/19/24 2:15 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>
>>>>>> How is that.
>>>>>>
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>>>
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>>>>>
>>>>
>>>> Those are different Ĥ.
>>>
>>> The question is always: Does Ĥ ⟨Ĥ⟩ halt?
>>
>> And H always gets it wrong, and every H^ has a H that gets it wrong.
>>
>
> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ in the above set that get it right
> and every TM that gets it right is not in the above set.
>
>
>

So?

Every input has a correct answer, so the question is correct.

If you want to define getting the wrong answer as making the problem
invalid to ask that decider, then you destroy your system as EVERY
decider is a correct decider for EVERYTHING.

You just think it is OK to LIE if it lets you claim to be correct.

That seems to be your primary method of operation.

On 3/20/24 8:04 PM, olcott wrote:
> On 3/20/2024 6:51 PM, Richard Damon wrote:
>> On 3/20/24 5:49 PM, olcott wrote:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>
>> And for these isntances of H^, the correct answer was NO.
>>
>
> "these isntances of H^, the correct answer was NO."
>
> *If every element of Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer then there*
> *are zero instances of Ĥ where the correct answer is NO*
>

Nope.

Every H that doesn't abort creates an H^ (H^) that the correct answer is No.

Those are the Hs that just fail to even be deciders.

Are you REALLY this stupid?

Or, are you just playing this dumb because you got off your Child
Pornograph charge by being mentally incompetent, and you can't let that
change.

On 3/20/2024 8:08 PM, Richard Damon wrote:
> On 3/20/24 8:59 PM, olcott wrote:
>> On 3/20/2024 7:50 PM, Richard Damon wrote:
>>> On 3/20/24 6:50 PM, olcott wrote:
>>>> On 3/20/2024 5:40 PM, immibis wrote:
>>>>> On 20/03/24 22:49, olcott wrote:
>>>>>> On 3/20/2024 4:42 PM, Richard Damon wrote:
>>>>>>> On 3/19/24 2:15 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>
>>>>>>> How is that.
>>>>>>>
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>>>>
>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>>>>>>
>>>>>
>>>>> Those are different Ĥ.
>>>>
>>>> The question is always: Does Ĥ ⟨Ĥ⟩ halt?
>>>
>>> And H always gets it wrong, and every H^ has a H that gets it wrong.
>>>
>>
>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ in the above set that get it right
>> and every TM that gets it right is not in the above set.
>>
>>
>>
>
> So?
>
> Every input has a correct answer, so the question is correct.
>

I think that it is time to go back to enforcing the title
of this thread or we will never get closure on anything.

On 3/20/2024 6:02 PM, Richard Damon wrote:
> On 3/20/24 6:01 PM, olcott wrote:
>> Every H(D,D) that doesn't abort its simulated input
>> never stops running.
>
> Yep, shows that H's that don't abort the D built on
> them won't be deciders...

This means that every H(D,D) that does abort its simulated
input is on the correct side of the abort/no abort decision.

--
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/24 6:54 PM, olcott wrote:
> On 3/20/2024 4:58 PM, Richard Damon wrote:
>> On 3/20/24 1:42 PM, olcott wrote:
>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>> 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.
>>>
>>> Can D correctly simulated by H terminate normally?
>> Strawman question!!!!
>>
>> Maybe not, but since D depends on its own instance of H, changing H
>> changes wht D does.
>>
>>
>>> 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 }
>>>
>>> *That you already know that no D simulated by any H can possibly*
>>> *reach its own line 06 in any finite number of steps of correct*
>>> *simulation proves that you know that I am correct*
>>
>> But that only shows that those OTHER Ds, built on Hs that don't abort
>> are non-halting.
>>
>
> *No silly name game changes this*
> Every H(D,D) that doesn't abort its simulated input never stops running.
> Every H(D,D) that doesn't abort its simulated input never stops running.
> Every H(D,D) that doesn't abort its simulated input never stops running.
>

On 3/20/2024 8:26 PM, Richard Damon wrote:
> On 3/20/24 6:54 PM, olcott wrote:
>> On 3/20/2024 4:58 PM, Richard Damon wrote:
>>> On 3/20/24 1:42 PM, olcott wrote:
>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>> 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.
>>>>
>>>> Can D correctly simulated by H terminate normally?
>>> Strawman question!!!!
>>>
>>> Maybe not, but since D depends on its own instance of H, changing H
>>> changes wht D does.
>>>
>>>
>>>> 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 }
>>>>
>>>> *That you already know that no D simulated by any H can possibly*
>>>> *reach its own line 06 in any finite number of steps of correct*
>>>> *simulation proves that you know that I am correct*
>>>
>>> But that only shows that those OTHER Ds, built on Hs that don't abort
>>> are non-halting.
>>>
>>
>> *No silly name game changes this*
>> Every H(D,D) that doesn't abort its simulated input never stops running.
>> Every H(D,D) that doesn't abort its simulated input never stops running.
>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>
>
> Which says that all the Hs that didn't abort SHOULD HAVE.
>
> But says NOTHING about the H^ for all the Hs that do abort.

On 3/20/24 6:46 PM, olcott wrote:
> On 3/20/2024 5:06 PM, Richard Damon wrote:
>> On 3/20/24 1:35 PM, olcott wrote:
>>> On 3/20/2024 10:13 AM, Richard Damon wrote:
>>>> On 3/19/24 11:06 PM, olcott wrote:
>>
>>>>>
>>>>> 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.
>>>>>
>>>>>
>>>>
>>>> And this last statement is your coup-de-grace to your logic. Since
>>>> THIS H only simulates for a certain SPECIFIC number of steps,
>>>
>>> Until it has mathematical induction proof that D simulated by H cannot
>>> possibly reach its own line 06, thus will never halt.
>>>
>>> That you keep insisting that H(D,D) must act as if it already aborted
>>> its simulation BEFORE it actually did this it ceases to look like any
>>> sort of honest mistake on your part.
>>>
>>
>> Yep, That is the rock and the hard place.
>>
>
> You didn't read my last 13 words carefully enough to realize that
> you just admitted to lying.
>

Sure I read them.

Yes, if the code for H says it aborts will abort the simulation of this
input, then it will ALWAYS act like it will abort the simulation of this
input.

You don't think it will?

How does it not do what its instructions say to do?

Remember what sort of instructions we use to build programs, they use
the information already gathered and do what the instructions say to do.

Since the instructions a FIXED and don't change, then the data gathered
will be the same for each instance from the same input, they will all
act exactly the same.

You don't think programs have "Free-Will" to just decide what to do on a
whim do you? Or be able to act on a "hunch" or a "Guess".

We DO have a form of "Crystal Ball" in the sense of being able to know
the answer a program WILL GIVE before a given copy of that program makes
the decision, we just use another copy of that program and give it the
same inputs.

This only runs into a problem if that program doesn't ever give an
answer, but it it is a decider, that can't happen (or in this case, H^
did its job by making H fail to answer)

On 3/20/2024 8:52 PM, Richard Damon wrote:
> On 3/20/24 6:46 PM, olcott wrote:
>> On 3/20/2024 5:06 PM, Richard Damon wrote:
>>> On 3/20/24 1:35 PM, olcott wrote:
>>>> On 3/20/2024 10:13 AM, Richard Damon wrote:
>>>>> On 3/19/24 11:06 PM, olcott wrote:
>>>
>>>>>>
>>>>>> 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.
>>>>>>
>>>>>>
>>>>>
>>>>> And this last statement is your coup-de-grace to your logic. Since
>>>>> THIS H only simulates for a certain SPECIFIC number of steps,
>>>>
>>>> Until it has mathematical induction proof that D simulated by H cannot
>>>> possibly reach its own line 06, thus will never halt.
>>>>
>>>> That you keep insisting that H(D,D) must act as if it already aborted
>>>> its simulation BEFORE it actually did this it ceases to look like any
>>>> sort of honest mistake on your part.
>>>>
>>>
>>> Yep, That is the rock and the hard place.
>>>
>>
>> You didn't read my last 13 words carefully enough to realize that
>> you just admitted to lying.
>>
>
> Sure I read them.
>
> Yes, if the code for H says it aborts will abort the simulation of this
> input, then it will ALWAYS act like it will abort the simulation of this
> input.
>
> You don't think it will?
>
> How does it not do what its instructions say to do?
>
> Remember what sort of instructions we use to build programs, they use
> the information already gathered and do what the instructions say to do.
>
> Since the instructions a FIXED and don't change, then the data gathered
> will be the same for each instance from the same input, they will all
> act exactly the same.
>
> You don't think programs have "Free-Will" to just decide what to do on a
> whim do you? Or be able to act on a "hunch" or a "Guess".
>
> We DO have a form of "Crystal Ball" in the sense of being able to know
> the answer a program WILL GIVE before a given copy of that program makes
> the decision, we just use another copy of that program and give it the
> same inputs.
>
> This only runs into a problem if that program doesn't ever give an
> answer, but it it is a decider, that can't happen (or in this case, H^
> did its job by making H fail to answer)

H(D,D) simply simulates it input until it sees that its
abort criteria has been met. It seems that you have very
persistently acted like this is 100% totally impossible.

--
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/24 7:05 PM, olcott wrote:
> On 3/20/2024 5:53 PM, Richard Damon wrote:
>> On 3/20/24 4:13 PM, olcott wrote:
>>> On 3/20/2024 2:57 PM, Richard Damon wrote:
>>>> On 3/20/24 2:07 PM, olcott wrote:
>>>
>>> <snip>
>>>
>>>>> Since I defined the term "incorrect question" and I defined the
>>>>> term "incorrect question instance" I cannot possibly have defined
>>>>> them incorrectly. These are stipulative definitions.
>>>>> https://en.wikipedia.org/wiki/Stipulative_definition
>>>>
>>>> And by stipulating your definition, you havve disconnected it from
>>>> any other use in the theory, in prticular, just because some
>>>> question turns out to be an Olcott-Incorrect Question doesn't me it
>>>> is an improper question to put to a decider to see if it meets its
>>>> defintion.
>>>>
>>>
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>
>> Because for THAT H^, the answer is NO
>>
>
> "That Ĥ" that you are referring to is not any actual Ĥ at all.
> every element of the in finite set Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong
> answer because whatever answer it provides is contradicted.
>
> <snip>

So, you are just admitting you are a LIAR?

Of course it is a specific H^ or nothing you have said makes any sense.

Your "Set" is a pairing of SPECIFIC H with a SPECIFIC H^ built from that H.

So, for each element of that set, which is what matters, there is a
correct answer, what ever H (H^) (H^) doesn't say.

>
>> The question was always "Correct" as it always had a correct answer
>> for all cases.
>>
>
> There is never any correct answer for any of these cases: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

Of course there is, I just gave it to you for each H that you create.

You are just caught in your lies.

>
>> All you have done is say that a decider can be considered
>> Olcott-Correct even if it LIES and gives wrong answers, because those
>> cases were just "incorrect question instances" for it.
>>
>
> We either change the question or we keep the question the same
> and reject the erroneous inputs.

WHY?

YOU are the one trying to come up with an alternate formulation for the
problem to try to convince people it might be useful for SOMETHING.

I'm just pointing out the problems with the best I can figure out what
you are meaning.

So far, it seems you want to allow deciders to lie if they can't get the
right answer.

>
>> Thus, you have destroyed the ability to gain knowledge by computing,
>> as we can never know if the answer was right unless we can show that
>> the decider did give the right answer, which is an uncomputable
>> problem, so we can never know something we didn't already know the
>> answer to.
>>
>
> Actually no one has showed that my abort decider ever gets
> the wrong answer. Instead of this the dishonest claim is
> made that it always gets the wrong answer.

No, we have shown that ALL the case you have presented, it gets the
wrong answer by the definition we agreed upon the other day.

H can abort its simulation and say non-halting if a UTM simulation of
the exact same input would be non-halting.

>
>>>
>>>>
>>>>> An {incorrect question instance} is any question that has no
>>>>> correct answer from the one that this question was posed to.
>>>>
>>>> And, if the "one" that question was posed to, by reason of the
>>>> "definition" of that "one" just doesn't give the correct answer, are
>>>> you saying that is enough to make that question instance invalid?
>>>>
>>>
>>> When the only reason that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ fails to provide a correct
>>> answer is that every answer is contradicted then these incorrect
>>> question instances must be tossed out.
>>>
>>
>> Excpet that now we can't tell which are those cases.
>
> If you quit lying about the abort decider being always wrong
> we can move on to seeing if there are any counter-examples
> that show it is not always right.
>
>

I am not lying. Show me a case where it WAS right about the ^ input.

Remember, our agreed upon definition of when it can decide to abort.

On 3/20/24 7:38 PM, olcott wrote:
> On 3/20/2024 6:34 PM, Richard Damon wrote:
>> On 3/20/24 6:52 PM, olcott wrote:
>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>> On 20/03/24 23:01, olcott wrote:
>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>
>>>>>>> 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 }
>>>>>>>
>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>> stops running.
>>>>>>>
>>>>>>>> It would be correct for this D. We can build another D, based on
>>>>>>>> the new H, but then the question changes, because the input
>>>>>>>> changes. The new H does not give the correct answer for the new D.
>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>
>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>> failed to give it. It seems Olcott is again confused, because he
>>>>>>>> uses the same names for different things.
>>>>>>>>
>>>>>>>
>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>> stops running.
>>>>>>>
>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>> attempt to get away with the strawman deception.
>>>>>>>
>>>>>>
>>>>>> Referring to a different D then the one you were given is a very
>>>>>> lame attempt to get away with a strawman deception.
>>>>>
>>>>> I am specifying a single D and an infinite set of implementations
>>>>> of H.
>>>>
>>>> If you are still talking about the Linz proof instead of some
>>>> bullshit, every D is based on exactly one H. If you change H but
>>>> don't change D, the D is still based on the old H and the correct
>>>> answer to the question "Does D(D) halt?" does not change.
>>>>
>>>
>>> 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 }
>>>
>>> If you want to construe this as an infinite set of H/D pairs where you
>>> are construing that each D is somehow different this makes no difference
>>> at all.
>>>
>>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>>
>>
>> Which STILL doesn't say what happens to the D's built on the Hs that
>> DO Abort.
>>
>
> *All of them are on the correct side of the abort/no abort decision*

On 3/20/2024 9:07 PM, Richard Damon wrote:
> On 3/20/24 7:05 PM, olcott wrote:
>> On 3/20/2024 5:53 PM, Richard Damon wrote:
>>> On 3/20/24 4:13 PM, olcott wrote:
>>>> On 3/20/2024 2:57 PM, Richard Damon wrote:
>>>>> On 3/20/24 2:07 PM, olcott wrote:
>>>>
>>>> <snip>
>>>>
>>>>>> Since I defined the term "incorrect question" and I defined the
>>>>>> term "incorrect question instance" I cannot possibly have defined
>>>>>> them incorrectly. These are stipulative definitions.
>>>>>> https://en.wikipedia.org/wiki/Stipulative_definition
>>>>>
>>>>> And by stipulating your definition, you havve disconnected it from
>>>>> any other use in the theory, in prticular, just because some
>>>>> question turns out to be an Olcott-Incorrect Question doesn't me it
>>>>> is an improper question to put to a decider to see if it meets its
>>>>> defintion.
>>>>>
>>>>
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>>
>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>
>>> Because for THAT H^, the answer is NO
>>>
>>
>> "That Ĥ" that you are referring to is not any actual Ĥ at all.
>> every element of the in finite set Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong
>> answer because whatever answer it provides is contradicted.
>>
>> <snip>
>
> So, you are just admitting you are a LIAR?
>
> Of course it is a specific H^ or nothing you have said makes any sense.
>
> Your "Set" is a pairing of SPECIFIC H with a SPECIFIC H^ built from that H.
>
> So, for each element of that set, which is what matters, there is a
> correct answer, what ever H (H^) (H^) doesn't say.
>
>>
>>> The question was always "Correct" as it always had a correct answer
>>> for all cases.
>>>
>>
>> There is never any correct answer for any of these cases: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>
> Of course there is, I just gave it to you for each H that you create.
>
> You are just caught in your lies.
>
>>
>>> All you have done is say that a decider can be considered
>>> Olcott-Correct even if it LIES and gives wrong answers, because those
>>> cases were just "incorrect question instances" for it.
>>>
>>
>> We either change the question or we keep the question the same
>> and reject the erroneous inputs.
>
> WHY?
>
> YOU are the one trying to come up with an alternate formulation for the
> problem to try to convince people it might be useful for SOMETHING.
>
> I'm just pointing out the problems with the best I can figure out what
> you are meaning.
>
> So far, it seems you want to allow deciders to lie if they can't get the
> right answer.
>
>>
>>> Thus, you have destroyed the ability to gain knowledge by computing,
>>> as we can never know if the answer was right unless we can show that
>>> the decider did give the right answer, which is an uncomputable
>>> problem, so we can never know something we didn't already know the
>>> answer to.
>>>
>>
>> Actually no one has showed that my abort decider ever gets
>> the wrong answer. Instead of this the dishonest claim is
>> made that it always gets the wrong answer.
>
> No, we have shown that ALL the case you have presented, it gets the
> wrong answer by the definition we agreed upon the other day.
>

In other words this H(D,D) does not need to abort its simulation
and if it does then it never needed to?

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 }

--
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 9:13 PM, Richard Damon wrote:
> On 3/20/24 7:38 PM, olcott wrote:
>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>> On 3/20/24 6:52 PM, olcott wrote:
>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>
>>>>>>>> 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 }
>>>>>>>>
>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>> stops running.
>>>>>>>>
>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>> on the new H, but then the question changes, because the input
>>>>>>>>> changes. The new H does not give the correct answer for the new D.
>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>
>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>> he uses the same names for different things.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>> stops running.
>>>>>>>>
>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>
>>>>>>>
>>>>>>> Referring to a different D then the one you were given is a very
>>>>>>> lame attempt to get away with a strawman deception.
>>>>>>
>>>>>> I am specifying a single D and an infinite set of implementations
>>>>>> of H.
>>>>>
>>>>> If you are still talking about the Linz proof instead of some
>>>>> bullshit, every D is based on exactly one H. If you change H but
>>>>> don't change D, the D is still based on the old H and the correct
>>>>> answer to the question "Does D(D) halt?" does not change.
>>>>>
>>>>
>>>> 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 }
>>>>
>>>> If you want to construe this as an infinite set of H/D pairs where you
>>>> are construing that each D is somehow different this makes no
>>>> difference
>>>> at all.
>>>>
>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>> running.
>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>> running.
>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>> running.
>>>>
>>>
>>> Which STILL doesn't say what happens to the D's built on the Hs that
>>> DO Abort.
>>>
>>
>> *All of them are on the correct side of the abort/no abort decision*
>
> Then why do they get the wrong answer?

On 3/20/24 7:54 PM, olcott wrote:
> On 3/20/2024 6:45 PM, Richard Damon wrote:
>> On 3/20/24 7:19 PM, olcott wrote:
>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>> On 3/20/24 6:01 PM, olcott wrote:
>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> 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.
>>>>>>>>>>
>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>
>>>>>>> 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 }
>>>>>>>
>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>> stops running.
>>>>>>>
>>>>>>>> It would be correct for this D. We can build another D, based on
>>>>>>>> the new H, but then the question changes, because the input
>>>>>>>> changes. The new H does not give the correct answer for the new D.
>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>
>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>> failed to give it. It seems Olcott is again confused, because he
>>>>>>>> uses the same names for different things.
>>>>>>>>
>>>>>>>
>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>> stops running.
>>>>>>>
>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>> attempt to get away with the strawman deception.
>>>>>>>
>>>>>>
>>>>>> Referring to a different D then the one you were given is a very
>>>>>> lame attempt to get away with a strawman deception.
>>>>>
>>>>> I am specifying a single D and an infinite set of implementations
>>>>> of H.
>>>>
>>>> you CAN'T do that and make D a Computation. If it isn't a
>>>> Computation, you aren't doing anything like Computability Theory and
>>>> NOTHING you talk about will have anything to do with the Halt Problem.
>>>>
>>>> You just stipulated yourself out of your "proof"
>>>>
>>>> If D just "refers" to the behavior of the decider that is deciding
>>>> it as a template, then you are going to need to define what that
>>>> REALLY MEANS, to see if your OLCOTT-ABORTING is at all an
>>>> interesting problem.
>>>>
>>>> Likely not, from what I see, so you are just stipulating the wasting
>>>> of the last 20 years, and probably the rest of your life.
>>>>
>>>>>
>>>>> If you want to construe this as an infinite set of H/D pairs where you
>>>>> are construing that each D is somehow different this makes no
>>>>> difference
>>>>> at all.
>>>>>
>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>> running.
>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>> running.
>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>> running.
>>>>>
>>>>>
>>>>
>>>> Yep, shows that H's that don't abort the D built on them won't be
>>>> deciders, so can't even get into the chalange of being a Halt Decider.
>>>>
>>> Yes it shows that.
>>>
>>>> Doesn't say anything about the D built on the Hs that abort.
>>>>
>>> Sure it does. It proves that every element of this set is on the
>>> correct side of the abort/no abort question.
>>
>> Nope.
>>
>> The set is just of those on the wrong side, and doesn't show they are
>> ALL of the set on the wrong side.
>>
>
> *You already admitted that*
> "H's that don't abort the D built on them won't be deciders"
> *thus are on the wrong side of the abort / no abort decision*

On 3/20/24 9:24 PM, olcott wrote:
> On 3/20/2024 8:08 PM, Richard Damon wrote:
>> On 3/20/24 8:59 PM, olcott wrote:
>>> On 3/20/2024 7:50 PM, Richard Damon wrote:
>>>> On 3/20/24 6:50 PM, olcott wrote:
>>>>> On 3/20/2024 5:40 PM, immibis wrote:
>>>>>> On 20/03/24 22:49, olcott wrote:
>>>>>>> On 3/20/2024 4:42 PM, Richard Damon wrote:
>>>>>>>> On 3/19/24 2:15 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>>
>>>>>>>> How is that.
>>>>>>>>
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>>> halt
>>>>>>>
>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then
>>>>>>> halts.
>>>>>>>
>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>>>>>>>
>>>>>>
>>>>>> Those are different Ĥ.
>>>>>
>>>>> The question is always: Does Ĥ ⟨Ĥ⟩ halt?
>>>>
>>>> And H always gets it wrong, and every H^ has a H that gets it wrong.
>>>>
>>>
>>> There are zero Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ in the above set that get it right
>>> and every TM that gets it right is not in the above set.
>>>
>>>
>>>
>>
>> So?
>>
>> Every input has a correct answer, so the question is correct.
>>
>
> I think that it is time to go back to enforcing the title
> of this thread or we will never get closure on anything.
>
> On 3/20/2024 6:02 PM, Richard Damon wrote:
> > On 3/20/24 6:01 PM, olcott wrote:
> >> Every H(D,D) that doesn't abort its simulated input
> >> never stops running.
> >
> > Yep, shows that H's that don't abort the D built on
> > them won't be deciders...
>
> This means that every H(D,D) that does abort its simulated
> input is on the correct side of the abort/no abort decision.
>

Nope.

FALSE DICHOTOMY.

INVALID LOGIC.

Turns out that ALL H are on the wrong side of the line, because the line
moves as you change the H looking at D because of the ACTUAL
pathological self-reference in your non-Turing Equivalent problem.

On 3/20/24 9:30 PM, olcott wrote:
> On 3/20/2024 8:26 PM, Richard Damon wrote:
>> On 3/20/24 6:54 PM, olcott wrote:
>>> On 3/20/2024 4:58 PM, Richard Damon wrote:
>>>> On 3/20/24 1:42 PM, olcott wrote:
>>>>> On 3/20/2024 10:06 AM, Richard Damon wrote:
>>>>>> 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.
>>>>>
>>>>> Can D correctly simulated by H terminate normally?
>>>> Strawman question!!!!
>>>>
>>>> Maybe not, but since D depends on its own instance of H, changing H
>>>> changes wht D does.
>>>>
>>>>
>>>>> 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 }
>>>>>
>>>>> *That you already know that no D simulated by any H can possibly*
>>>>> *reach its own line 06 in any finite number of steps of correct*
>>>>> *simulation proves that you know that I am correct*
>>>>
>>>> But that only shows that those OTHER Ds, built on Hs that don't
>>>> abort are non-halting.
>>>>
>>>
>>> *No silly name game changes this*
>>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>> Every H(D,D) that doesn't abort its simulated input never stops running.
>>>
>>
>> Which says that all the Hs that didn't abort SHOULD HAVE.
>>
>> But says NOTHING about the H^ for all the Hs that do abort.
>
> Sure it does. It conclusively proves that they are all on the
> correct side of the abort/no abort decision.
>

On 3/20/24 10:05 PM, olcott wrote:
> On 3/20/2024 8:52 PM, Richard Damon wrote:
>> On 3/20/24 6:46 PM, olcott wrote:
>>> On 3/20/2024 5:06 PM, Richard Damon wrote:
>>>> On 3/20/24 1:35 PM, olcott wrote:
>>>>> On 3/20/2024 10:13 AM, Richard Damon wrote:
>>>>>> On 3/19/24 11:06 PM, olcott wrote:
>>>>
>>>>>>>
>>>>>>> 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.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And this last statement is your coup-de-grace to your logic. Since
>>>>>> THIS H only simulates for a certain SPECIFIC number of steps,
>>>>>
>>>>> Until it has mathematical induction proof that D simulated by H cannot
>>>>> possibly reach its own line 06, thus will never halt.
>>>>>
>>>>> That you keep insisting that H(D,D) must act as if it already aborted
>>>>> its simulation BEFORE it actually did this it ceases to look like any
>>>>> sort of honest mistake on your part.
>>>>>
>>>>
>>>> Yep, That is the rock and the hard place.
>>>>
>>>
>>> You didn't read my last 13 words carefully enough to realize that
>>> you just admitted to lying.
>>>
>>
>> Sure I read them.
>>
>> Yes, if the code for H says it aborts will abort the simulation of
>> this input, then it will ALWAYS act like it will abort the simulation
>> of this input.
>>
>> You don't think it will?
>>
>> How does it not do what its instructions say to do?
>>
>> Remember what sort of instructions we use to build programs, they use
>> the information already gathered and do what the instructions say to do.
>>
>> Since the instructions a FIXED and don't change, then the data
>> gathered will be the same for each instance from the same input, they
>> will all act exactly the same.
>>
>> You don't think programs have "Free-Will" to just decide what to do on
>> a whim do you? Or be able to act on a "hunch" or a "Guess".
>>
>> We DO have a form of "Crystal Ball" in the sense of being able to know
>> the answer a program WILL GIVE before a given copy of that program
>> makes the decision, we just use another copy of that program and give
>> it the same inputs.
>>
>> This only runs into a problem if that program doesn't ever give an
>> answer, but it it is a decider, that can't happen (or in this case, H^
>> did its job by making H fail to answer)
>
> H(D,D) simply simulates it input until it sees that its
> abort criteria has been met. It seems that you have very
> persistently acted like this is 100% totally impossible.
>

Except that your aborting criteria doesn't actually meet the test you
agreed on for a correct abort.

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

Remember, A correcrt simulator is one the doesn't stop until it reaches
the end.

That has ALWAYS been my definition of a correct simulator.

On 3/20/24 10:14 PM, olcott wrote:
> On 3/20/2024 9:07 PM, Richard Damon wrote:
>> On 3/20/24 7:05 PM, olcott wrote:
>>> On 3/20/2024 5:53 PM, Richard Damon wrote:
>>>> On 3/20/24 4:13 PM, olcott wrote:
>>>>> On 3/20/2024 2:57 PM, Richard Damon wrote:
>>>>>> On 3/20/24 2:07 PM, olcott wrote:
>>>>>
>>>>> <snip>
>>>>>
>>>>>>> Since I defined the term "incorrect question" and I defined the
>>>>>>> term "incorrect question instance" I cannot possibly have defined
>>>>>>> them incorrectly. These are stipulative definitions.
>>>>>>> https://en.wikipedia.org/wiki/Stipulative_definition
>>>>>>
>>>>>> And by stipulating your definition, you havve disconnected it from
>>>>>> any other use in the theory, in prticular, just because some
>>>>>> question turns out to be an Olcott-Incorrect Question doesn't me
>>>>>> it is an improper question to put to a decider to see if it meets
>>>>>> its defintion.
>>>>>>
>>>>>
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>>>
>>>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>>>
>>>> Because for THAT H^, the answer is NO
>>>>
>>>
>>> "That Ĥ" that you are referring to is not any actual Ĥ at all.
>>> every element of the in finite set Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong
>>> answer because whatever answer it provides is contradicted.
>>>
>>> <snip>
>>
>> So, you are just admitting you are a LIAR?
>>
>> Of course it is a specific H^ or nothing you have said makes any sense.
>>
>> Your "Set" is a pairing of SPECIFIC H with a SPECIFIC H^ built from
>> that H.
>>
>> So, for each element of that set, which is what matters, there is a
>> correct answer, what ever H (H^) (H^) doesn't say.
>>
>>>
>>>> The question was always "Correct" as it always had a correct answer
>>>> for all cases.
>>>>
>>>
>>> There is never any correct answer for any of these cases: Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
>>
>> Of course there is, I just gave it to you for each H that you create.
>>
>> You are just caught in your lies.
>>
>>>
>>>> All you have done is say that a decider can be considered
>>>> Olcott-Correct even if it LIES and gives wrong answers, because
>>>> those cases were just "incorrect question instances" for it.
>>>>
>>>
>>> We either change the question or we keep the question the same
>>> and reject the erroneous inputs.
>>
>> WHY?
>>
>> YOU are the one trying to come up with an alternate formulation for
>> the problem to try to convince people it might be useful for SOMETHING.
>>
>> I'm just pointing out the problems with the best I can figure out what
>> you are meaning.
>>
>> So far, it seems you want to allow deciders to lie if they can't get
>> the right answer.
>>
>>>
>>>> Thus, you have destroyed the ability to gain knowledge by computing,
>>>> as we can never know if the answer was right unless we can show that
>>>> the decider did give the right answer, which is an uncomputable
>>>> problem, so we can never know something we didn't already know the
>>>> answer to.
>>>>
>>>
>>> Actually no one has showed that my abort decider ever gets
>>> the wrong answer. Instead of this the dishonest claim is
>>> made that it always gets the wrong answer.
>>
>> No, we have shown that ALL the case you have presented, it gets the
>> wrong answer by the definition we agreed upon the other day.
>>
>
> In other words this H(D,D) does not need to abort its simulation
> and if it does then it never needed to?

The TOP level H doesn't need to, but does, because that is its programming.

In fact, at EVERY level that level doesn't need to but does, as that is
its programming. It doesn't need to, because the next level down will.

If you program H to not abort, then we get a DIFFERENT behavior from D,
and that will be non-halting, so H will NEED to abort, but doesn't.

You seem to forget that D explcitly depend on the behavior of H, so you
can't ignore that,

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

On 3/20/2024 9:18 PM, Richard Damon wrote:
> On 3/20/24 7:54 PM, olcott wrote:
>> On 3/20/2024 6:45 PM, Richard Damon wrote:
>>> On 3/20/24 7:19 PM, olcott wrote:
>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>> On 3/20/24 6:01 PM, olcott wrote:
>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> 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.
>>>>>>>>>>>
>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>
>>>>>>>> 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 }
>>>>>>>>
>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>> stops running.
>>>>>>>>
>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>> on the new H, but then the question changes, because the input
>>>>>>>>> changes. The new H does not give the correct answer for the new D.
>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>> correct for this D. We can build another D, based on the new H,
>>>>>>>>> but then the question changes, because the input changes. The
>>>>>>>>> new H does not give the correct answer for the new D.
>>>>>>>>>
>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>> he uses the same names for different things.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>> stops running.
>>>>>>>>
>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>
>>>>>>>
>>>>>>> Referring to a different D then the one you were given is a very
>>>>>>> lame attempt to get away with a strawman deception.
>>>>>>
>>>>>> I am specifying a single D and an infinite set of implementations
>>>>>> of H.
>>>>>
>>>>> you CAN'T do that and make D a Computation. If it isn't a
>>>>> Computation, you aren't doing anything like Computability Theory
>>>>> and NOTHING you talk about will have anything to do with the Halt
>>>>> Problem.
>>>>>
>>>>> You just stipulated yourself out of your "proof"
>>>>>
>>>>> If D just "refers" to the behavior of the decider that is deciding
>>>>> it as a template, then you are going to need to define what that
>>>>> REALLY MEANS, to see if your OLCOTT-ABORTING is at all an
>>>>> interesting problem.
>>>>>
>>>>> Likely not, from what I see, so you are just stipulating the
>>>>> wasting of the last 20 years, and probably the rest of your life.
>>>>>
>>>>>>
>>>>>> If you want to construe this as an infinite set of H/D pairs where
>>>>>> you
>>>>>> are construing that each D is somehow different this makes no
>>>>>> difference
>>>>>> at all.
>>>>>>
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>>
>>>>>>
>>>>>
>>>>> Yep, shows that H's that don't abort the D built on them won't be
>>>>> deciders, so can't even get into the chalange of being a Halt Decider.
>>>>>
>>>> Yes it shows that.
>>>>
>>>>> Doesn't say anything about the D built on the Hs that abort.
>>>>>
>>>> Sure it does. It proves that every element of this set is on the
>>>> correct side of the abort/no abort question.
>>>
>>> Nope.
>>>
>>> The set is just of those on the wrong side, and doesn't show they are
>>> ALL of the set on the wrong side.
>>>
>>
>> *You already admitted that*
>> "H's that don't abort the D built on them won't be deciders"
>> *thus are on the wrong side of the abort / no abort decision*
>
> Right, but nothing says the others aren't on the wrong side too, since
> they get a different D since D's behavior changes based on the H it gets
> paired with.
>

On 3/20/24 10:18 PM, olcott wrote:
> On 3/20/2024 9:13 PM, Richard Damon wrote:
>> On 3/20/24 7:38 PM, olcott wrote:
>>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>>> On 3/20/24 6:52 PM, olcott wrote:
>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>> stops running.
>>>>>>>>>
>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>> on the new H, but then the question changes, because the input
>>>>>>>>>> changes. The new H does not give the correct answer for the
>>>>>>>>>> new D.
>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>
>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>> stops running.
>>>>>>>>>
>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Referring to a different D then the one you were given is a very
>>>>>>>> lame attempt to get away with a strawman deception.
>>>>>>>
>>>>>>> I am specifying a single D and an infinite set of implementations
>>>>>>> of H.
>>>>>>
>>>>>> If you are still talking about the Linz proof instead of some
>>>>>> bullshit, every D is based on exactly one H. If you change H but
>>>>>> don't change D, the D is still based on the old H and the correct
>>>>>> answer to the question "Does D(D) halt?" does not change.
>>>>>>
>>>>>
>>>>> 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 }
>>>>>
>>>>> If you want to construe this as an infinite set of H/D pairs where you
>>>>> are construing that each D is somehow different this makes no
>>>>> difference
>>>>> at all.
>>>>>
>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>> running.
>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>> running.
>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>> running.
>>>>>
>>>>
>>>> Which STILL doesn't say what happens to the D's built on the Hs that
>>>> DO Abort.
>>>>
>>>
>>> *All of them are on the correct side of the abort/no abort decision*
>>
>> Then why do they get the wrong answer?
>
> Are you trying to get away with contradicting yourself?
>
> On 3/20/2024 6:02 PM, Richard Damon wrote:
> > On 3/20/24 6:01 PM, olcott wrote:
> >> Every H(D,D) that doesn't abort its simulated input
> >> never stops running.
> >
> > Yep, shows that H's that don't abort the D built on
> > them won't be deciders...
>
>

On 3/20/24 10:37 PM, olcott wrote:
> On 3/20/2024 9:18 PM, Richard Damon wrote:
>> On 3/20/24 7:54 PM, olcott wrote:
>>> On 3/20/2024 6:45 PM, Richard Damon wrote:
>>>> On 3/20/24 7:19 PM, olcott wrote:
>>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>>> On 3/20/24 6:01 PM, olcott wrote:
>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> 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.
>>>>>>>>>>>>
>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>
>>>>>>>>> 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 }
>>>>>>>>>
>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>> stops running.
>>>>>>>>>
>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>> on the new H, but then the question changes, because the input
>>>>>>>>>> changes. The new H does not give the correct answer for the
>>>>>>>>>> new D.
>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>
>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>> stops running.
>>>>>>>>>
>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>
>>>>>>>>
>>>>>>>> Referring to a different D then the one you were given is a very
>>>>>>>> lame attempt to get away with a strawman deception.
>>>>>>>
>>>>>>> I am specifying a single D and an infinite set of implementations
>>>>>>> of H.
>>>>>>
>>>>>> you CAN'T do that and make D a Computation. If it isn't a
>>>>>> Computation, you aren't doing anything like Computability Theory
>>>>>> and NOTHING you talk about will have anything to do with the Halt
>>>>>> Problem.
>>>>>>
>>>>>> You just stipulated yourself out of your "proof"
>>>>>>
>>>>>> If D just "refers" to the behavior of the decider that is deciding
>>>>>> it as a template, then you are going to need to define what that
>>>>>> REALLY MEANS, to see if your OLCOTT-ABORTING is at all an
>>>>>> interesting problem.
>>>>>>
>>>>>> Likely not, from what I see, so you are just stipulating the
>>>>>> wasting of the last 20 years, and probably the rest of your life.
>>>>>>
>>>>>>>
>>>>>>> If you want to construe this as an infinite set of H/D pairs
>>>>>>> where you
>>>>>>> are construing that each D is somehow different this makes no
>>>>>>> difference
>>>>>>> at all.
>>>>>>>
>>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>>> running.
>>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>>> running.
>>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>>> running.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> Yep, shows that H's that don't abort the D built on them won't be
>>>>>> deciders, so can't even get into the chalange of being a Halt
>>>>>> Decider.
>>>>>>
>>>>> Yes it shows that.
>>>>>
>>>>>> Doesn't say anything about the D built on the Hs that abort.
>>>>>>
>>>>> Sure it does. It proves that every element of this set is on the
>>>>> correct side of the abort/no abort question.
>>>>
>>>> Nope.
>>>>
>>>> The set is just of those on the wrong side, and doesn't show they
>>>> are ALL of the set on the wrong side.
>>>>
>>>
>>> *You already admitted that*
>>> "H's that don't abort the D built on them won't be deciders"
>>> *thus are on the wrong side of the abort / no abort decision*
>>
>> Right, but nothing says the others aren't on the wrong side too, since
>> they get a different D since D's behavior changes based on the H it
>> gets paired with.
>>
>
> 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 }
>
> In other words you are still trying to get away with the
> ridiculous nonsense that H is not correct to abort its simulation?
>

On 3/20/2024 9:41 PM, Richard Damon wrote:
> On 3/20/24 10:18 PM, olcott wrote:
>> On 3/20/2024 9:13 PM, Richard Damon wrote:
>>> On 3/20/24 7:38 PM, olcott wrote:
>>>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>>>> On 3/20/24 6:52 PM, olcott wrote:
>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>>> on the new H, but then the question changes, because the
>>>>>>>>>>> input changes. The new H does not give the correct answer for
>>>>>>>>>>> the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>
>>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Referring to a different D then the one you were given is a
>>>>>>>>> very lame attempt to get away with a strawman deception.
>>>>>>>>
>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>> implementations of H.
>>>>>>>
>>>>>>> If you are still talking about the Linz proof instead of some
>>>>>>> bullshit, every D is based on exactly one H. If you change H but
>>>>>>> don't change D, the D is still based on the old H and the correct
>>>>>>> answer to the question "Does D(D) halt?" does not change.
>>>>>>>
>>>>>>
>>>>>> 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 }
>>>>>>
>>>>>> If you want to construe this as an infinite set of H/D pairs where
>>>>>> you
>>>>>> are construing that each D is somehow different this makes no
>>>>>> difference
>>>>>> at all.
>>>>>>
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>>
>>>>>
>>>>> Which STILL doesn't say what happens to the D's built on the Hs
>>>>> that DO Abort.
>>>>>
>>>>
>>>> *All of them are on the correct side of the abort/no abort decision*
>>>
>>> Then why do they get the wrong answer?
>>
>> Are you trying to get away with contradicting yourself?
>>
>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>  > On 3/20/24 6:01 PM, olcott wrote:
>>  >> Every H(D,D) that doesn't abort its simulated input
>>  >> never stops running.
>>  >
>>  > Yep, shows that H's that don't abort the D built on
>>  > them won't be deciders...
>>
>>
>
>
> Nothing contradictory about that.
>
> You have two distinct classes of H, that make DIFFERENT errors due to
> different behaviors they create.
>
> Those whose programming make them never abort create a D that will never
> halt, because its H get stuck in an infinite simulation loop, the the
> top level H also gets stuck in. It NEEDS to abort, but doesn't
>

On 3/20/2024 9:41 PM, Richard Damon wrote:
> On 3/20/24 10:18 PM, olcott wrote:
>> On 3/20/2024 9:13 PM, Richard Damon wrote:
>>> On 3/20/24 7:38 PM, olcott wrote:
>>>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>>>> On 3/20/24 6:52 PM, olcott wrote:
>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>>> on the new H, but then the question changes, because the
>>>>>>>>>>> input changes. The new H does not give the correct answer for
>>>>>>>>>>> the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>
>>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Referring to a different D then the one you were given is a
>>>>>>>>> very lame attempt to get away with a strawman deception.
>>>>>>>>
>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>> implementations of H.
>>>>>>>
>>>>>>> If you are still talking about the Linz proof instead of some
>>>>>>> bullshit, every D is based on exactly one H. If you change H but
>>>>>>> don't change D, the D is still based on the old H and the correct
>>>>>>> answer to the question "Does D(D) halt?" does not change.
>>>>>>>
>>>>>>
>>>>>> 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 }
>>>>>>
>>>>>> If you want to construe this as an infinite set of H/D pairs where
>>>>>> you
>>>>>> are construing that each D is somehow different this makes no
>>>>>> difference
>>>>>> at all.
>>>>>>
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>>
>>>>>
>>>>> Which STILL doesn't say what happens to the D's built on the Hs
>>>>> that DO Abort.
>>>>>
>>>>
>>>> *All of them are on the correct side of the abort/no abort decision*
>>>
>>> Then why do they get the wrong answer?
>>
>> Are you trying to get away with contradicting yourself?
>>
>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>  > On 3/20/24 6:01 PM, olcott wrote:
>>  >> Every H(D,D) that doesn't abort its simulated input
>>  >> never stops running.
>>  >
>>  > Yep, shows that H's that don't abort the D built on
>>  > them won't be deciders...
>>
>>
>
>
> Nothing contradictory about that.
>
> You have two distinct classes of H, that make DIFFERENT errors due to
> different behaviors they create.
>
> Those whose programming make them never abort create a D that will never
> halt, because its H get stuck in an infinite simulation loop, the the
> top level H also gets stuck in. It NEEDS to abort, but doesn't
>
> Then you have those H whose programming makes themselves abort, that
> create a D that calls an H that also aborts its simulation and returns
> causse that D to Halt. Thus this H, will it aborts its simulation,
> didn't NEED to abort it.

On 3/20/2024 9:46 PM, Richard Damon wrote:
> On 3/20/24 10:37 PM, olcott wrote:
>> On 3/20/2024 9:18 PM, Richard Damon wrote:
>>> On 3/20/24 7:54 PM, olcott wrote:
>>>> On 3/20/2024 6:45 PM, Richard Damon wrote:
>>>>> On 3/20/24 7:19 PM, olcott wrote:
>>>>>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>>>>>> On 3/20/24 6:01 PM, olcott wrote:
>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>>> on the new H, but then the question changes, because the
>>>>>>>>>>> input changes. The new H does not give the correct answer for
>>>>>>>>>>> the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>
>>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Referring to a different D then the one you were given is a
>>>>>>>>> very lame attempt to get away with a strawman deception.
>>>>>>>>
>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>> implementations of H.
>>>>>>>
>>>>>>> you CAN'T do that and make D a Computation. If it isn't a
>>>>>>> Computation, you aren't doing anything like Computability Theory
>>>>>>> and NOTHING you talk about will have anything to do with the Halt
>>>>>>> Problem.
>>>>>>>
>>>>>>> You just stipulated yourself out of your "proof"
>>>>>>>
>>>>>>> If D just "refers" to the behavior of the decider that is
>>>>>>> deciding it as a template, then you are going to need to define
>>>>>>> what that REALLY MEANS, to see if your OLCOTT-ABORTING is at all
>>>>>>> an interesting problem.
>>>>>>>
>>>>>>> Likely not, from what I see, so you are just stipulating the
>>>>>>> wasting of the last 20 years, and probably the rest of your life.
>>>>>>>
>>>>>>>>
>>>>>>>> If you want to construe this as an infinite set of H/D pairs
>>>>>>>> where you
>>>>>>>> are construing that each D is somehow different this makes no
>>>>>>>> difference
>>>>>>>> at all.
>>>>>>>>
>>>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>>>> running.
>>>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>>>> running.
>>>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>>>> running.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> Yep, shows that H's that don't abort the D built on them won't be
>>>>>>> deciders, so can't even get into the chalange of being a Halt
>>>>>>> Decider.
>>>>>>>
>>>>>> Yes it shows that.
>>>>>>
>>>>>>> Doesn't say anything about the D built on the Hs that abort.
>>>>>>>
>>>>>> Sure it does. It proves that every element of this set is on the
>>>>>> correct side of the abort/no abort question.
>>>>>
>>>>> Nope.
>>>>>
>>>>> The set is just of those on the wrong side, and doesn't show they
>>>>> are ALL of the set on the wrong side.
>>>>>
>>>>
>>>> *You already admitted that*
>>>> "H's that don't abort the D built on them won't be deciders"
>>>> *thus are on the wrong side of the abort / no abort decision*
>>>
>>> Right, but nothing says the others aren't on the wrong side too,
>>> since they get a different D since D's behavior changes based on the
>>> H it gets paired with.
>>>
>>
>> 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 }
>>
>> In other words you are still trying to get away with the
>> ridiculous nonsense that H is not correct to abort its simulation?
>>
>
> Right, because it FAILS to meet the requirments that YOU agreed to.
>
> 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.
> >
>
> So since:
>
>
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
>          // Note, still H as H is still the "decider"
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   UTM(D,D);
> 12 }
>
> Will halt, H was not justified in aborting its input.
>
> You are not allowed to argue with some other H that isn't this H as that
> changes the behavior of D.
>
> You are just proving you lack of understanding on how logic works.

On 3/20/2024 9:41 PM, Richard Damon wrote:
> On 3/20/24 10:18 PM, olcott wrote:
>> On 3/20/2024 9:13 PM, Richard Damon wrote:
>>> On 3/20/24 7:38 PM, olcott wrote:
>>>> On 3/20/2024 6:34 PM, Richard Damon wrote:
>>>>> On 3/20/24 6:52 PM, olcott wrote:
>>>>>> On 3/20/2024 5:47 PM, immibis wrote:
>>>>>>> On 20/03/24 23:01, olcott wrote:
>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote:
>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote:
>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote:
>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott:
>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote:
>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> 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.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Therefore the correct answer H(D,D) should give is "yes".
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H.
>>>>>>>>>>
>>>>>>>>>> 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 }
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>>> It would be correct for this D. We can build another D, based
>>>>>>>>>>> on the new H, but then the question changes, because the
>>>>>>>>>>> input changes. The new H does not give the correct answer for
>>>>>>>>>>> the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
>>>>>>>>>>> No. The H that answers 'yes' is a different H. It would be
>>>>>>>>>>> correct for this D. We can build another D, based on the new
>>>>>>>>>>> H, but then the question changes, because the input changes.
>>>>>>>>>>> The new H does not give the correct answer for the new D.
>>>>>>>>>>>
>>>>>>>>>>> Both questions have a correct answer, but the corresponding H
>>>>>>>>>>> failed to give it. It seems Olcott is again confused, because
>>>>>>>>>>> he uses the same names for different things.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Every H(D,D) that does not abort its simulation input never
>>>>>>>>>> stops running.
>>>>>>>>>>
>>>>>>>>>> Trying to refer to a different H than every H is a very lame
>>>>>>>>>> attempt to get away with the strawman deception.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Referring to a different D then the one you were given is a
>>>>>>>>> very lame attempt to get away with a strawman deception.
>>>>>>>>
>>>>>>>> I am specifying a single D and an infinite set of
>>>>>>>> implementations of H.
>>>>>>>
>>>>>>> If you are still talking about the Linz proof instead of some
>>>>>>> bullshit, every D is based on exactly one H. If you change H but
>>>>>>> don't change D, the D is still based on the old H and the correct
>>>>>>> answer to the question "Does D(D) halt?" does not change.
>>>>>>>
>>>>>>
>>>>>> 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 }
>>>>>>
>>>>>> If you want to construe this as an infinite set of H/D pairs where
>>>>>> you
>>>>>> are construing that each D is somehow different this makes no
>>>>>> difference
>>>>>> at all.
>>>>>>
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>> Every H(D,D) that doesn't abort its simulated input never stops
>>>>>> running.
>>>>>>
>>>>>
>>>>> Which STILL doesn't say what happens to the D's built on the Hs
>>>>> that DO Abort.
>>>>>
>>>>
>>>> *All of them are on the correct side of the abort/no abort decision*
>>>
>>> Then why do they get the wrong answer?
>>
>> Are you trying to get away with contradicting yourself?
>>
>> On 3/20/2024 6:02 PM, Richard Damon wrote:
>>  > On 3/20/24 6:01 PM, olcott wrote:
>>  >> Every H(D,D) that doesn't abort its simulated input
>>  >> never stops running.
>>  >
>>  > Yep, shows that H's that don't abort the D built on
>>  > them won't be deciders...
>>
>>
>
>
> Nothing contradictory about that.
>
> You have two distinct classes of H, that make DIFFERENT errors due to
> different behaviors they create.
>
> Those whose programming make them never abort create a D that will never
> halt, because its H get stuck in an infinite simulation loop, the the
> top level H also gets stuck in. It NEEDS to abort, but doesn't
>
> Then you have those H whose programming makes themselves abort, that
> create a D that calls an H that also aborts its simulation

On 20/03/24 23:50, olcott wrote:
> On 3/20/2024 5:40 PM, immibis wrote:
>> On 20/03/24 22:49, olcott wrote:
>>> On 3/20/2024 4:42 PM, Richard Damon wrote:
>>>> On 3/19/24 2:15 PM, 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 ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>
>>>> How is that.
>>>>
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ says Ĥ ⟨Ĥ⟩ halts and fails to halt.
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   says Ĥ ⟨Ĥ⟩ does not halt and then halts.
>>>
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.
>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>>>
>>
>> Those are different Ĥ.
>
> The question is always: Does Ĥ ⟨Ĥ⟩ halt?

This is an infinite set of questions if Ĥ is an infinite set of
programs. Which one are you actually talking about?