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.

>
> That you keep trying to change the subject to a different instance
> of D is ALWAYS an instance of the strawman deception.
>

So why do YOU do it.

A D that calls an H that doesn't abort, isn't this D, so you are just
showing that you arguement is a STRAWMAN.

That, our your basic question isn't about the COMPUTATION described to
H, so also a STRAWMAN.

So, you are just shown to be working with a STRAWMAN, maybe you have to
choose which one it is, but you are shown to be lying about working on
the problem you claim to be.

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

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

If H waits till it can actually prove the answer, it will never halt and
fails to be a decider.

If H gets impatient and aborts before that, it has to "guess" the
answer, and H^/D makes it so that all guess are wrong.

The H that is deciding only gets to see what it has simulated.

The actual behavior of the machine, knows the decision and has acted
contray (if H decided).

So yes, the machine that this H is deciding on has already run and used
the answer that this H will make, because it can know it because of
determinism.

You don't seem to understand that concept, maybe because you just don't
understand how programming works.

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

Yep, you are showing that you have no idea of what is happening.

Remember, there is actually only ONE call to H(D,D) in any instance of a
program, so there is no "Second Call"

There are simulations of calls, and Simulations of Simulations of calls.

And if the top level simulator of the input aborts its simulation, then
when we compare its decision to an actual CORRECT simulation of that
input, we see that this simulation includes one more level of
simulation, and that the first layer down of simulation see the exact
same behavior, and ALSO aborts its simulation, and returns and then Halts.

Thus, the CORRECT SIMULATION of the input halts, because the simulated
machine will do the exact same aborting, and thus THIS OUTER simulation
didn't "need" to abort, as a correct unaborted simulation would have halted.

of course, machines do what they have been programmed to do, so it
aborted anyway, since "Get the Right Answer" is not an algorithmic step.

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

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

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

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 Ĥ. If Ĥ is a different program, the answer to the
question "Does Ĥ ⟨Ĥ⟩ halt?" can also be different. This is why Fred
chose to give every DIFFERENT Ĥ program a DIFFERENT NAME.

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.

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

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.

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?

Every element of the infinite set does have the property
of getting the wrong answer because its answer has been
contradicted. *No silly name game change change that*

> If Ĥ is a different program, the answer to the
> question "Does Ĥ ⟨Ĥ⟩ halt?" can also be different. This is why Fred
> chose to give every DIFFERENT Ĥ program a DIFFERENT NAME.

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

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

> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.

Becaue for THAT DIFFERENT H^, the answer is YES

>
> Therefore:
> Does Ĥ ⟨Ĥ⟩ halt? is an incorrect question instance when posed to Ĥ.H.

So, you assert that ALL deciders are correct decider for ANY QUESTION
you give them, as if the answer they give is wrong, that is just an
incorrect question for that decider.

>
> It is logically impossible for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide a correct answer
> because every answer that Ĥ.H provides is contradicted.

Right, because the template generates a NEW QUESTION for every different
H, and finds an input that it happes to get wrong.

>
> If the inability to do the logically impossible was any actual
> limitation then humans would be limited in that they cannot
> correctly answer this question: What time is is (yes or no)?

But knowledge of what IS logically impossible is useful.

Yes, PROVING that Halt Deciding is impossible didn't change what could
be computed, as you couldn't have done it even before it was proven.

But KNOW that this isn't computable help you understand that it isn't,
so you don't try. Knowing that some things are uncomputable was a big
step, as it meant people knwo better than to waste a lifetime looking
for the way to do something that might not have been doable.

>
>> This seems to be something you don't understand about Stipulating your
>> definitions.
>>
>>>
>>> An {incorrect question} is any question that has no correct answer.
>>> What time is it (yes or no)? is an incorrect question.
>>>
>> So, by YOUR definitoin, the "Halting Question", namely the question,
>> "Does the Computation described by this input Halt?" is not an
>> {incorrect question}, as EVERY specific computation will either Halt
>> or Not.
>>
>
> Once the incorrect question instances are tossed out then it is
> a correct question.

ILLOGICAL.

The question was always "Correct" as it always had a correct answer for
all cases.

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.

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.

>
>>
>>> 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. As D could have
been built on an "encrypted" copy of H which modified it in any of an
infinite number of ways so we can't tell it was H, so we can't trust ANY
answers, unless we knew the answer before hand.

This is the problem with this sort of logic, it devoles into nothing is
knowable that didn't start easily knowable.

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

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>

> 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 ⟨Ĥ⟩ ⟨Ĥ⟩

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

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

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

--
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 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.
>
> Doesn't say anything about the D built on the Hs that abort.
>

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.

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

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

On 3/20/24 7:08 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.
>>
>> Doesn't say anything about the D built on the Hs that abort.
>>
>
> If every element of a set is defined to have a certain property
> then that makes any claim that some of the elements don't have
> this property a blatant lie.

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.

On 3/20/24 5:49 PM, 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.
>>

AGAIN WITH YOUR LIES

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

> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers  NO is wrong.
>

And for these OTHER instances of H^, the correct answer was YES.

DIFFERENT H^s, so different answers are possible.

Just shows that the correct answer for some H^ depends on the exact H^
it is, and the H it was built on.

As has been pointed out, you seem to like INTENTIONALLY confusing things
by calling all your Hs the sane name.

This is like arresting your brother Darrly for robbing the bank, when it
was the OTHER brother Darrly that did it.

Just proves you are intentionally being deceitful, so they are LIES, and
not just "Honest Mistakes".

Some times I wonder if you do that so YOU can't keep them straight so
you can lie to yourself better.

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

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*

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

>
> Every element of the infinite set does have the property
> of getting the wrong answer because its answer has been
> contradicted. *No silly name game change change that*

But you ARE playing a "silly name game" as the H^ Here:

>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers YES is wrong.

Is a different H^ then the one HERE:

>>> Every Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ that answers NO is wrong.

So, you are caught LYING again.

Seems like you lie every time you speak.

>
>> If Ĥ is a different program, the answer to the question "Does Ĥ ⟨Ĥ⟩
>> halt?" can also be different. This is why Fred chose to give every
>> DIFFERENT Ĥ program a DIFFERENT NAME.
>