On 3/8/24 7:06 PM, olcott wrote:
> On 3/8/2024 8:47 PM, Richard Damon wrote:
>> On 3/8/24 6:25 PM, olcott wrote:
>>> On 3/8/2024 8:16 PM, Richard Damon wrote:
>>>> On 3/8/24 5:54 PM, olcott wrote:
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> must report on what happens in the pathological program.
>>>>> When we specify how the pathological program will transition to Ĥ.Hqn
>>>>> then we know what H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> will see and how it will report.
>>>>>
>>>>>
>>>>
>>>> The problem is that the direct application of the Linz Turing
>>>> Machine template doesn't generate the Pathological Olcott-Machine
>>>> template, because their execution semantics are diffferent, due to
>>>> the modification caused by the master UTM.
>>>
>>> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> is smarter than Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly be.
>>
>> Irreverent.
>>
>> THe ^ templete has a DEFINITION of the semantics of what it is to do.
>>
>> Don't follow them, and you are just lying about what you are doing.
>
> H ⟨H⟩ ⟨H⟩ ⊢* H.qy // H applied to ⟨H⟩ halts
> H ⟨H⟩ ⟨H⟩ ⊢* H.qn // H applied to ⟨H⟩ does not halt
>
> I was agreeing with you in that Olcott machines include sequences
> specified by their ⊢* that Turing Machines do not have.
>
>>>
>>>> The actual Pathological input for Olcot-Machines needs to get to the
>>>> state H^.H with (H^) (H^) <H> on the tape,
>>>
>>> That is not how Olcott machines are stipulated to operate.
>>> Ĥ ⟨Ĥ⟩ has <Ĥ> appended to its own tape.
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ has <H> appended to its own tape.
>>>
>>> *You are just ignoring how Olcott machines are specified to work*
>>>
>>
>> And, after H^ starts, it can do whatever it wants to the tape.
> That is off topic for now because:

But WHY?

If you have a problem with your definion of an Olcot machine, don't you
want to know BEFORE you spend a lot of time on it

>
> *I cannot tolerate never getting closure on anything*
> *I cannot tolerate never getting closure on anything*
> *I cannot tolerate never getting closure on anything*

Then go ahead and spend a week figuring out what you what this H to do,
then find out that your definition of Olcott machines doesn't do what
you think it does, and have to throw that all away.

IS that what you REALLY want?

>
> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
> therefore
> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>
> I still don't know the detailed steps of how
> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
> YET WE CAN SEE THAT IT IS CORRECT

No, you see that you have a set of results that makes

H (H^) (H^) <H> -> qy correct,
but doesn't make the other result
H^.H (H^) (H^) <H^> -> qn correct.

H^.H (H^) (H^) <H^> correct as by going to qn, it is rejecting the input
and thus saying that H^ (H^) <H^> is non-halting when it is halting.

For H to be correct, ALL COPIES of it need to answer accorting to the
mapping.

You just don't understand your requireents

You have just admitted that H isn't a computaton of just the description
of the computation to be decided, as a Halt Decider MUST be, as the Halt
Mapping is just a function of the Computation to be decided.

>
> You still don't understand how the indirect
> criteria does compute halting as a side-effect.
>

Excpet it gets this case WRONG.

And WRONG is WRONG, and to say it is correct is just a LIE.

On 3/8/24 7:14 PM, olcott wrote:
> On 3/8/2024 9:03 PM, Richard Damon wrote:
>> On 3/8/24 6:34 PM, olcott wrote:
>>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>>> The Mapping describes the answer that we want for ALL possible
>>>> inputs. It becomes the specification of the problem.
>>>>
>>>
>>> You still can't understand how computing the mapping
>>> from all inputs to final state Ĥ.Hqn or non final state
>>> Ĥ.Hqy on the basis of the indirect criteria also causes
>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>>
>>
>> Because your "indirect Criteria" map differs from the DEFINED DIRECT
>> Criteria map.
>>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> The indirect criteria provides Ĥ.H the basis for
> which wrong answer it must return and provides
> H with the basis to return the correct halt status.

And if it gives a WRONG answer, then H is just WRONG.

>
> So far everyone in world the has no idea what
> basis Ĥ.H could use to determine its wrong answer.
> *They leave it wide open with a question mark*

But it needs to get the RIGHT answer to be correct.

And we KNOW the "basis" it is what H does.

>
> When we hypothesize a basis such that H gets
> the correct answer and Ĥ.H can provide some
> answer then this question mark is resolved.
>

But you don't seem to understand that H^.H IS an instance of the
computation of H, and as such, MUST deliver the "right" answer per the
mapping that H is DEFINED to give.

You aren't allowed to LIE here.

The algorithm of H computes some mapping of (M) d <TMD> to accept / reject.

This mapping, for ALL inputs, must match the HALTING mapping.

Thus the algorithm of H, which is at H^.H must go to qy if M d will
halt, and to qn if M d will not halt.

Since M = H^ and d = (H^)

This means that, as you comment says

H^.H (H^) (H^) <H^> should have gone to qy if H^ (H^) halts, which it
did, so the algorithm of H is proven to be WRONG.

You are just showing you don't understand what you are doing.

On 3/8/2024 9:48 PM, Richard Damon wrote:
> On 3/8/24 7:14 PM, olcott wrote:
>> On 3/8/2024 9:03 PM, Richard Damon wrote:
>>> On 3/8/24 6:34 PM, olcott wrote:
>>>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>>>> The Mapping describes the answer that we want for ALL possible
>>>>> inputs. It becomes the specification of the problem.
>>>>>
>>>>
>>>> You still can't understand how computing the mapping
>>>> from all inputs to final state Ĥ.Hqn or non final state
>>>> Ĥ.Hqy on the basis of the indirect criteria also causes
>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>>>
>>>
>>> Because your "indirect Criteria" map differs from the DEFINED DIRECT
>>> Criteria map.
>>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> The indirect criteria provides Ĥ.H the basis for
>> which wrong answer it must return and provides
>> H with the basis to return the correct halt status.
>
> And if it gives a WRONG answer, then H is just WRONG.
>
>>
>> So far everyone in world the has no idea what
>> basis Ĥ.H could use to determine its wrong answer.
>> *They leave it wide open with a question mark*
>
> But it needs to get the RIGHT answer to be correct.

*Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
*Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
*Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*

--
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/8/2024 9:41 PM, Richard Damon wrote:
> On 3/8/24 7:06 PM, olcott wrote:
>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>> therefore
>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>
>> I still don't know the detailed steps of how
>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>> YET WE CAN SEE THAT IT IS CORRECT
>
> No, you see that you have a set of results that makes

Every H needs a criteria to use whether it is contradicted
or not. When it is not contradicted this same criteria
correctly decides halting for its input.

When H is contradicted it provides a consistent way
that H can provide the wrong answer.

You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
or it will never halt.

When every H has the same way to say that, then when it is
contradicted it has something to say and when it is not
contradicted this is the correct halt status of its input.

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

On 3/8/24 8:05 PM, olcott wrote:
> On 3/8/2024 9:48 PM, Richard Damon wrote:
>> On 3/8/24 7:14 PM, olcott wrote:
>>> On 3/8/2024 9:03 PM, Richard Damon wrote:
>>>> On 3/8/24 6:34 PM, olcott wrote:
>>>>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>>>>> The Mapping describes the answer that we want for ALL possible
>>>>>> inputs. It becomes the specification of the problem.
>>>>>>
>>>>>
>>>>> You still can't understand how computing the mapping
>>>>> from all inputs to final state Ĥ.Hqn or non final state
>>>>> Ĥ.Hqy on the basis of the indirect criteria also causes
>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>>>>
>>>>
>>>> Because your "indirect Criteria" map differs from the DEFINED DIRECT
>>>> Criteria map.
>>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> The indirect criteria provides Ĥ.H the basis for
>>> which wrong answer it must return and provides
>>> H with the basis to return the correct halt status.
>>
>> And if it gives a WRONG answer, then H is just WRONG.
>>
>>>
>>> So far everyone in world the has no idea what
>>> basis Ĥ.H could use to determine its wrong answer.
>>> *They leave it wide open with a question mark*
>>
>> But it needs to get the RIGHT answer to be correct.
>
> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>
>

But if it is the wrong answer, it is wrong.

Why don't you understand that?

H^.H (H^) (H^) <H^> will do EXACTLY what the algorith for H, applied to
that input tells it to do.

That creates a behavior which determines what answer H gives, and the
behavior that H must answer about.

Given the algroithm has been defined (or else we don't HAVE an H so we
don't have an H^ to be talking about) the FACT of the behavior is fixed,
it will do what it will do. We can then evaluate if it got the right
answer by comparing the answer that it gave, with the answer the mapping
we are trying to compute says it should have given to be correct.

Since, by the pathological nature of H^, the answer that it gives will
NEVER match the answer that it should have given, this H will just
always be wrong.

The question isn't wrong, as the mapping tells us what the answer should
have been. It just turns out that the mapping can't be computed because
for ANY machine that we might try to make a decider, there WILL be an
input corresponding to this contrary nature, and thus we can conclude
that the Halting Mapping is just uncomputable, meaning no Computable
Algorithm (like a Turing Machine) exists that can ALWAYs compute the
right answer.

On 3/8/24 8:20 PM, olcott wrote:
> On 3/8/2024 9:41 PM, Richard Damon wrote:
>> On 3/8/24 7:06 PM, olcott wrote:
>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>> therefore
>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>
>>> I still don't know the detailed steps of how
>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>> YET WE CAN SEE THAT IT IS CORRECT
>>
>> No, you see that you have a set of results that makes
>
> Every H needs a criteria to use whether it is contradicted
> or not. When it is not contradicted this same criteria
> correctly decides halting for its input.
>
> When H is contradicted it provides a consistent way
> that H can provide the wrong answer.

But if you admit that it will get a wrong answer, how can you claim it
is a correct Halt Decider, which means it always gets the Right answer.

You are just admitting that you are lying about refuting the proof that
we can not make an always correct Halt Decider.

You don't get to claim to be right, when the machine gives the wrong answer.

>
> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
> or it will never halt.
>
> When every H has the same way to say that, then when it is
> contradicted it has something to say and when it is not
> contradicted this is the correct halt status of its input.
>

No, if ANY copy of H gives the wrong answer to some input, then H is not
a Halt Decider.

Just saying "something" when stuck, doesn't make it correct.

On 3/8/2024 10:28 PM, Richard Damon wrote:
> On 3/8/24 8:05 PM, olcott wrote:
>> On 3/8/2024 9:48 PM, Richard Damon wrote:
>>> On 3/8/24 7:14 PM, olcott wrote:
>>>> On 3/8/2024 9:03 PM, Richard Damon wrote:
>>>>> On 3/8/24 6:34 PM, olcott wrote:
>>>>>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>>>>>> The Mapping describes the answer that we want for ALL possible
>>>>>>> inputs. It becomes the specification of the problem.
>>>>>>>
>>>>>>
>>>>>> You still can't understand how computing the mapping
>>>>>> from all inputs to final state Ĥ.Hqn or non final state
>>>>>> Ĥ.Hqy on the basis of the indirect criteria also causes
>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>>>>>
>>>>>
>>>>> Because your "indirect Criteria" map differs from the DEFINED
>>>>> DIRECT Criteria map.
>>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> The indirect criteria provides Ĥ.H the basis for
>>>> which wrong answer it must return and provides
>>>> H with the basis to return the correct halt status.
>>>
>>> And if it gives a WRONG answer, then H is just WRONG.
>>>
>>>>
>>>> So far everyone in world the has no idea what
>>>> basis Ĥ.H could use to determine its wrong answer.
>>>> *They leave it wide open with a question mark*
>>>
>>> But it needs to get the RIGHT answer to be correct.
>>
>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>
>>
>
> But if it is the wrong answer, it is wrong.
>
> Why don't you understand that?
>

It is only wrong for the input and not the external decider.

The criteria is very very special in the the same criteria that lets
the input derive some answer lets the external decider derive the
correct answer.

When each H determines the halt status of its input from its own point
of view then the external one corresponds to the actual behavior of the
input when it is directly executed.

--
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/8/2024 10:33 PM, Richard Damon wrote:
> On 3/8/24 8:20 PM, olcott wrote:
>> On 3/8/2024 9:41 PM, Richard Damon wrote:
>>> On 3/8/24 7:06 PM, olcott wrote:
>>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>>> therefore
>>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>>
>>>> I still don't know the detailed steps of how
>>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>>> YET WE CAN SEE THAT IT IS CORRECT
>>>
>>> No, you see that you have a set of results that makes
>>
>> Every H needs a criteria to use whether it is contradicted
>> or not. When it is not contradicted this same criteria
>> correctly decides halting for its input.
>>
>> When H is contradicted it provides a consistent way
>> that H can provide the wrong answer.
>
> But if you admit that it will get a wrong answer, how can you claim it
> is a correct Halt Decider, which means it always gets the Right answer.
>

When the input data gets the wrong answer this allows the
actual decider to get the right answer.

> You are just admitting that you are lying about refuting the proof that
> we can not make an always correct Halt Decider.
>
> You don't get to claim to be right, when the machine gives the wrong
> answer.
>
>>
>> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
>> or it will never halt.
>>
>> When every H has the same way to say that, then when it is
>> contradicted it has something to say and when it is not
>> contradicted this is the correct halt status of its input.
>>
>
> No, if ANY copy of H gives the wrong answer to some input, then H is not
> a Halt Decider.

When the input data gets the wrong answer this allows the
actual decider to get the right answer.

>
> Just saying "something" when stuck, doesn't make it correct.
>

--
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/8/24 8:41 PM, olcott wrote:
> On 3/8/2024 10:28 PM, Richard Damon wrote:
>> On 3/8/24 8:05 PM, olcott wrote:
>>> On 3/8/2024 9:48 PM, Richard Damon wrote:
>>>> On 3/8/24 7:14 PM, olcott wrote:
>>>>> On 3/8/2024 9:03 PM, Richard Damon wrote:
>>>>>> On 3/8/24 6:34 PM, olcott wrote:
>>>>>>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>>>>>>> The Mapping describes the answer that we want for ALL possible
>>>>>>>> inputs. It becomes the specification of the problem.
>>>>>>>>
>>>>>>>
>>>>>>> You still can't understand how computing the mapping
>>>>>>> from all inputs to final state Ĥ.Hqn or non final state
>>>>>>> Ĥ.Hqy on the basis of the indirect criteria also causes
>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>>>>>>
>>>>>>
>>>>>> Because your "indirect Criteria" map differs from the DEFINED
>>>>>> DIRECT Criteria map.
>>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>>
>>>>> The indirect criteria provides Ĥ.H the basis for
>>>>> which wrong answer it must return and provides
>>>>> H with the basis to return the correct halt status.
>>>>
>>>> And if it gives a WRONG answer, then H is just WRONG.
>>>>
>>>>>
>>>>> So far everyone in world the has no idea what
>>>>> basis Ĥ.H could use to determine its wrong answer.
>>>>> *They leave it wide open with a question mark*
>>>>
>>>> But it needs to get the RIGHT answer to be correct.
>>>
>>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>>
>>>
>>
>> But if it is the wrong answer, it is wrong.
>>
>> Why don't you understand that?
>>
>
> It is only wrong for the input and not the external decider.

It is WRONG.

DEFINITIOBN.

>
> The criteria is very very special in the the same criteria that lets
> the input derive some answer lets the external decider derive the
> correct answer.

No, the criteria for H to be a Halt Decider is PRECISELY Defined.

IF H gives the wrong answer, ANYWHERE, if FAILS to be a Halt Decider.

>
> When each H determines the halt status of its input from its own point
> of view then the external one corresponds to the actual behavior of the
> input when it is directly executed.
>

But it isn't to answer "From its own point view". It is to answer
according to the REQUIREMENT to compute the MAPPING, which is OBJECTIVE.

You don't get to convert the OBJECTIVE standard to a SUBJECTIVE
standard, that is just a LIE.

They ALL must be correct, not just the top level.

You are just proving you don't understand the definition of a COMPUTATION.

That is your downfall, you just don't know the rules of what you are
talking about, and think it ok to LIE about what you are doing.

On 3/8/24 8:45 PM, olcott wrote:
> On 3/8/2024 10:33 PM, Richard Damon wrote:
>> On 3/8/24 8:20 PM, olcott wrote:
>>> On 3/8/2024 9:41 PM, Richard Damon wrote:
>>>> On 3/8/24 7:06 PM, olcott wrote:
>>>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>>>> therefore
>>>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>>>
>>>>> I still don't know the detailed steps of how
>>>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>>>> YET WE CAN SEE THAT IT IS CORRECT
>>>>
>>>> No, you see that you have a set of results that makes
>>>
>>> Every H needs a criteria to use whether it is contradicted
>>> or not. When it is not contradicted this same criteria
>>> correctly decides halting for its input.
>>>
>>> When H is contradicted it provides a consistent way
>>> that H can provide the wrong answer.
>>
>> But if you admit that it will get a wrong answer, how can you claim it
>> is a correct Halt Decider, which means it always gets the Right answer.
>>
>
> When the input data gets the wrong answer this allows the
> actual decider to get the right answer.

But the algorith at H^.H IS an instanc eof the decide,r, and must get
the answer right.

You are just admitting to being a STUPID LIAR.

>
>> You are just admitting that you are lying about refuting the proof
>> that we can not make an always correct Halt Decider.
>>
>> You don't get to claim to be right, when the machine gives the wrong
>> answer.
>>
>>>
>>> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
>>> or it will never halt.
>>>
>>> When every H has the same way to say that, then when it is
>>> contradicted it has something to say and when it is not
>>> contradicted this is the correct halt status of its input.
>>>
>>
>> No, if ANY copy of H gives the wrong answer to some input, then H is
>> not a Halt Decider.
>
> When the input data gets the wrong answer this allows the
> actual decider to get the right answer.

And thus you admit that H is WRONG, as all copies of it are the ACTUAL
DECIDER.

That is the nature of a Computation.

ANY instance of the algorithm applied to its input must get the same
answer for the same data and to be correct must match the mapping that
it is supposed to derive.

You are just proving you don't understand the definition of the field,
but claim to be following them by saying you are working on the Halting
Problem.

>
>>
>> Just saying "something" when stuck, doesn't make it correct.
>>
>

On 3/8/2024 10:52 PM, Richard Damon wrote:
> On 3/8/24 8:41 PM, olcott wrote:
>> On 3/8/2024 10:28 PM, Richard Damon wrote:
>>> On 3/8/24 8:05 PM, olcott wrote:
>>>> On 3/8/2024 9:48 PM, Richard Damon wrote:
>>>>> On 3/8/24 7:14 PM, olcott wrote:
>>>>>> On 3/8/2024 9:03 PM, Richard Damon wrote:
>>>>>>> On 3/8/24 6:34 PM, olcott wrote:
>>>>>>>> On 3/8/2024 8:24 PM, Richard Damon wrote:
>>>>>>>>> The Mapping describes the answer that we want for ALL possible
>>>>>>>>> inputs. It becomes the specification of the problem.
>>>>>>>>>
>>>>>>>>
>>>>>>>> You still can't understand how computing the mapping
>>>>>>>> from all inputs to final state Ĥ.Hqn or non final state
>>>>>>>> Ĥ.Hqy on the basis of the indirect criteria also causes
>>>>>>>> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to correctly compute halting.
>>>>>>>>
>>>>>>>
>>>>>>> Because your "indirect Criteria" map differs from the DEFINED
>>>>>>> DIRECT Criteria map.
>>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not
>>>>>> halt
>>>>>>
>>>>>> The indirect criteria provides Ĥ.H the basis for
>>>>>> which wrong answer it must return and provides
>>>>>> H with the basis to return the correct halt status.
>>>>>
>>>>> And if it gives a WRONG answer, then H is just WRONG.
>>>>>
>>>>>>
>>>>>> So far everyone in world the has no idea what
>>>>>> basis Ĥ.H could use to determine its wrong answer.
>>>>>> *They leave it wide open with a question mark*
>>>>>
>>>>> But it needs to get the RIGHT answer to be correct.
>>>>
>>>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>>> *Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> must have some basis for its wrong answer*
>>>>
>>>>
>>>
>>> But if it is the wrong answer, it is wrong.
>>>
>>> Why don't you understand that?
>>>
>>
>> It is only wrong for the input and not the external decider.
>
> It is WRONG.
>

A wrong answer that doesn't count.

Ĥ only proves that an otherwise correct decider
can be changed so that it functions incorrectly.

It does not show that H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer.

> DEFINITIOBN.
>
>>
>> The criteria is very very special in the the same criteria that lets
>> the input derive some answer lets the external decider derive the
>> correct answer.
>
> No, the criteria for H to be a Halt Decider is PRECISELY Defined.
>
> IF H gives the wrong answer, ANYWHERE, if FAILS to be a Halt Decider.

What is you basis for Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to provide some answer?

>
>>
>> When each H determines the halt status of its input from its own point
>> of view then the external one corresponds to the actual behavior of the
>> input when it is directly executed.
>>
>
> But it isn't to answer "From its own point view". It is to answer
> according to the REQUIREMENT to compute the MAPPING, which is OBJECTIVE.
>
> You don't get to convert the OBJECTIVE standard to a SUBJECTIVE
> standard, that is just a LIE.
>
> They ALL must be correct, not just the top level.

Ĥ only proves that an otherwise correct decider
can be changed so that it functions incorrectly.
It does not show that H ⟨Ĥ⟩ ⟨Ĥ⟩ gets the wrong answer.

>
> You are just proving you don't understand the definition of a COMPUTATION.
>
> That is your downfall, you just don't know the rules of what you are
> talking about, and think it ok to LIE about what you are doing.

--
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/8/2024 10:58 PM, Richard Damon wrote:
> On 3/8/24 8:45 PM, olcott wrote:
>> On 3/8/2024 10:33 PM, Richard Damon wrote:
>>> On 3/8/24 8:20 PM, olcott wrote:
>>>> On 3/8/2024 9:41 PM, Richard Damon wrote:
>>>>> On 3/8/24 7:06 PM, olcott wrote:
>>>>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>>>>> therefore
>>>>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>>>>
>>>>>> I still don't know the detailed steps of how
>>>>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>>>>> YET WE CAN SEE THAT IT IS CORRECT
>>>>>
>>>>> No, you see that you have a set of results that makes
>>>>
>>>> Every H needs a criteria to use whether it is contradicted
>>>> or not. When it is not contradicted this same criteria
>>>> correctly decides halting for its input.
>>>>
>>>> When H is contradicted it provides a consistent way
>>>> that H can provide the wrong answer.
>>>
>>> But if you admit that it will get a wrong answer, how can you claim
>>> it is a correct Halt Decider, which means it always gets the Right
>>> answer.
>>>
>>
>> When the input data gets the wrong answer this allows the
>> actual decider to get the right answer.
>
> But the algorith at H^.H IS an instanc eof the decide,r, and must get
> the answer right.
>
> You are just admitting to being a STUPID LIAR.

You are the one that does not understand that making changes to
a machine to so it will not work properly does make this machine
not work properly.

>>
>>> You are just admitting that you are lying about refuting the proof
>>> that we can not make an always correct Halt Decider.
>>>
>>> You don't get to claim to be right, when the machine gives the wrong
>>> answer.
>>>
>>>>
>>>> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
>>>> or it will never halt.
>>>>
>>>> When every H has the same way to say that, then when it is
>>>> contradicted it has something to say and when it is not
>>>> contradicted this is the correct halt status of its input.
>>>>
>>>
>>> No, if ANY copy of H gives the wrong answer to some input, then H is
>>> not a Halt Decider.
>>
>> When the input data gets the wrong answer this allows the
>> actual decider to get the right answer.
>
> And thus you admit that H is WRONG, as all copies of it are the ACTUAL
> DECIDER.
>

I never said anything like that. I say that Ĥ.H and you twist
this to man that I said H was wrong.

> That is the nature of a Computation.
>
> ANY instance of the algorithm applied to its input must get the same
> answer for the same data and to be correct must match the mapping that
> it is supposed to derive.
>

*Every H reports whether its input halts from its POV*

This causes contradicted instances to get the wrong answer
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ↦ Ĥ.Hqn

This causes uncontradicted instances to get the right answer
H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ↦ H.qy

> You are just proving you don't understand the definition of the field,
> but claim to be following them by saying you are working on the Halting
> Problem.
>
>>
>>>
>>> Just saying "something" when stuck, doesn't make it correct.
>>>
>>
>

--
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/8/24 9:10 PM, olcott wrote:
> On 3/8/2024 10:58 PM, Richard Damon wrote:
>> On 3/8/24 8:45 PM, olcott wrote:
>>> On 3/8/2024 10:33 PM, Richard Damon wrote:
>>>> On 3/8/24 8:20 PM, olcott wrote:
>>>>> On 3/8/2024 9:41 PM, Richard Damon wrote:
>>>>>> On 3/8/24 7:06 PM, olcott wrote:
>>>>>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>>>>>> therefore
>>>>>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>>>>>
>>>>>>> I still don't know the detailed steps of how
>>>>>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>>>>>> YET WE CAN SEE THAT IT IS CORRECT
>>>>>>
>>>>>> No, you see that you have a set of results that makes
>>>>>
>>>>> Every H needs a criteria to use whether it is contradicted
>>>>> or not. When it is not contradicted this same criteria
>>>>> correctly decides halting for its input.
>>>>>
>>>>> When H is contradicted it provides a consistent way
>>>>> that H can provide the wrong answer.
>>>>
>>>> But if you admit that it will get a wrong answer, how can you claim
>>>> it is a correct Halt Decider, which means it always gets the Right
>>>> answer.
>>>>
>>>
>>> When the input data gets the wrong answer this allows the
>>> actual decider to get the right answer.
>>
>> But the algorith at H^.H IS an instanc eof the decide,r, and must get
>> the answer right.
>>
>> You are just admitting to being a STUPID LIAR.
>
>
> You are the one that does not understand that making changes to
> a machine to so it will not work properly does make this machine
> not work properly.

What CHANGES have I been saying to make?

YOU need to define the details of the Algorithm that you will call H.

You have full control over it, it just nedds to be actual Turing Machine
code, or code that is ACTUAL the equivalent of a Turing Machine.

That means it is defined by what steps it does, and how it does it. NOT
"get such-and-such an answer".

These are fixed deterministic steps.

Once you do that, the Linz proof defines how to built the machine H^ by
its SEMANTIC DEFINITION of H^ adjusts the tape so it can use an exact
copy of the algorithm of the H it is to confound, with exactly the same
inputs as that will have when answering about this H^ applied to its input.

We can the run your H with the description of that H^, and see what it
predicts H^ (H^) will do.

We can also then run that H^ (H^) and see what it does.

Because of the requirement that H be a computation, then the copy of H
at H^.H since it is given the exact same input as when we ran it
earlier, must give the exact same answer as it did above.

We can then compare the results of what H said its input would do to
what the input actually did. If they match, it passed that test.

If they differ, H was proven to not be a correct Halt Decider.

Nowhere did we make "changes" to any machine to make it not work
properly. The algorithm you provided for H was exactly used to make H,
and to be put at H^.H.

Remember, Machines are DEFINED by the algorithm they were defined with,
NOT the specification or requirements that algorithm was supposed to
meet. It is the creater of the Algorithms job to meet that, and the
algorithm will either acheive of fail at meeting the reqquirements.

>
>>>
>>>> You are just admitting that you are lying about refuting the proof
>>>> that we can not make an always correct Halt Decider.
>>>>
>>>> You don't get to claim to be right, when the machine gives the wrong
>>>> answer.
>>>>
>>>>>
>>>>> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
>>>>> or it will never halt.
>>>>>
>>>>> When every H has the same way to say that, then when it is
>>>>> contradicted it has something to say and when it is not
>>>>> contradicted this is the correct halt status of its input.
>>>>>
>>>>
>>>> No, if ANY copy of H gives the wrong answer to some input, then H is
>>>> not a Halt Decider.
>>>
>>> When the input data gets the wrong answer this allows the
>>> actual decider to get the right answer.
>>
>> And thus you admit that H is WRONG, as all copies of it are the ACTUAL
>> DECIDER.
>>
>
> I never said anything like that. I say that Ĥ.H and you twist
> this to man that I said H was wrong.

Because the code at H^.H *IS* an instance of H.

If it isn't, then you have been lying and I can't help you.

>
>> That is the nature of a Computation.
>>
>> ANY instance of the algorithm applied to its input must get the same
>> answer for the same data and to be correct must match the mapping that
>> it is supposed to derive.
>>
>
> *Every H reports whether its input halts from its POV*

It might HAVE to do that, but to meet its requirements it needs to
answer about the FACTUAL behavior of the computation its input defines.

The question is OBJECTIVE, so has only one correct answer (which of
course depends on the algorithm of the input, which in this case also
depends on the algorithm of the decider the input was designed to be
contrary to)

Since we are talking about running the machine, it has a defined
algorithm, and the we have a defined input, and that has a defined
behavior which establishes the correct answer. Which won't be the answer
that H will give, so it will be wrong.

>
> This causes contradicted instances to get the wrong answer
> Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> ↦ Ĥ.Hqn

If so, then the algorithm just fails to meet the requirements, so the
algorithm of H isn't the algorithm of a Halt Decider.

The specifications don't allow the machine to do something it isn't
programmed to do.

>
> This causes uncontradicted instances to get the right answer
> H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> ↦ H.qy

But since the other instance of H didn't, the algorithm of H isn't a
correct Halt Decider.

>
>> You are just proving you don't understand the definition of the field,
>> but claim to be following them by saying you are working on the
>> Halting Problem.
>>
>>>
>>>>
>>>> Just saying "something" when stuck, doesn't make it correct.
>>>>
>>>
>>
>

On 3/8/2024 11:43 PM, Richard Damon wrote:
> On 3/8/24 9:10 PM, olcott wrote:
>> On 3/8/2024 10:58 PM, Richard Damon wrote:
>>> On 3/8/24 8:45 PM, olcott wrote:
>>>> On 3/8/2024 10:33 PM, Richard Damon wrote:
>>>>> On 3/8/24 8:20 PM, olcott wrote:
>>>>>> On 3/8/2024 9:41 PM, Richard Damon wrote:
>>>>>>> On 3/8/24 7:06 PM, olcott wrote:
>>>>>>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>>>>>>> therefore
>>>>>>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>>>>>>
>>>>>>>> I still don't know the detailed steps of how
>>>>>>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>>>>>>> YET WE CAN SEE THAT IT IS CORRECT
>>>>>>>
>>>>>>> No, you see that you have a set of results that makes
>>>>>>
>>>>>> Every H needs a criteria to use whether it is contradicted
>>>>>> or not. When it is not contradicted this same criteria
>>>>>> correctly decides halting for its input.
>>>>>>
>>>>>> When H is contradicted it provides a consistent way
>>>>>> that H can provide the wrong answer.
>>>>>
>>>>> But if you admit that it will get a wrong answer, how can you claim
>>>>> it is a correct Halt Decider, which means it always gets the Right
>>>>> answer.
>>>>>
>>>>
>>>> When the input data gets the wrong answer this allows the
>>>> actual decider to get the right answer.
>>>
>>> But the algorith at H^.H IS an instanc eof the decide,r, and must get
>>> the answer right.
>>>
>>> You are just admitting to being a STUPID LIAR.
>>
>>
>> You are the one that does not understand that making changes to
>> a machine to so it will not work properly does make this machine
>> not work properly.
>
> What CHANGES have I been saying to make?
>

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

> YOU need to define the details of the Algorithm that you will call H.
>
> You have full control over it, it just nedds to be actual Turing Machine
> code, or code that is ACTUAL the equivalent of a Turing Machine.
>
> That means it is defined by what steps it does, and how it does it. NOT
> "get such-and-such an answer".
>
> These are fixed deterministic steps.
>
> Once you do that, the Linz proof defines how to built the machine H^ by
> its SEMANTIC DEFINITION of H^ adjusts the tape so it can use an exact
> copy of the algorithm of the H it is to confound, with exactly the same
> inputs as that will have when answering about this H^ applied to its input.
>
> We can the run your H with the description of that H^, and see what it
> predicts H^ (H^) will do.
>
> We can also then run that H^ (H^) and see what it does.
>
> Because of the requirement that H be a computation, then the copy of H
> at H^.H since it is given the exact same input as when we ran it
> earlier, must give the exact same answer as it did above.
>
> We can then compare the results of what H said its input would do to
> what the input actually did. If they match, it passed that test.
>
> If they differ, H was proven to not be a correct Halt Decider.
>
> Nowhere did we make "changes" to any machine to make it not work
> properly. The algorithm you provided for H was exactly used to make H,
> and to be put at H^.H.
>
> Remember, Machines are DEFINED by the algorithm they were defined with,
> NOT the specification or requirements that algorithm was supposed to
> meet. It is the creater of the Algorithms job to meet that, and the
> algorithm will either acheive of fail at meeting the reqquirements.
>
>>
>>>>
>>>>> You are just admitting that you are lying about refuting the proof
>>>>> that we can not make an always correct Halt Decider.
>>>>>
>>>>> You don't get to claim to be right, when the machine gives the
>>>>> wrong answer.
>>>>>
>>>>>>
>>>>>> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
>>>>>> or it will never halt.
>>>>>>
>>>>>> When every H has the same way to say that, then when it is
>>>>>> contradicted it has something to say and when it is not
>>>>>> contradicted this is the correct halt status of its input.
>>>>>>
>>>>>
>>>>> No, if ANY copy of H gives the wrong answer to some input, then H
>>>>> is not a Halt Decider.
>>>>
>>>> When the input data gets the wrong answer this allows the
>>>> actual decider to get the right answer.
>>>
>>> And thus you admit that H is WRONG, as all copies of it are the
>>> ACTUAL DECIDER.
>>>
>>
>> I never said anything like that. I say that Ĥ.H and you twist
>> this to man that I said H was wrong.
>
> Because the code at H^.H *IS* an instance of H.
>

H ⟨Ĥ⟩ ⟨Ĥ⟩ is not contradicted is not the same one
that is contradicted Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

> If it isn't, then you have been lying and I can't help you.
>
>>
>>> That is the nature of a Computation.
>>>
>>> ANY instance of the algorithm applied to its input must get the same
>>> answer for the same data and to be correct must match the mapping
>>> that it is supposed to derive.
>>>
>>
>> *Every H reports whether its input halts from its POV*
>
> It might HAVE to do that, but to meet its requirements it needs to
> answer about the FACTUAL behavior of the computation its input defines.

The one that is contradicted Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets right answer from its POV
which is the wrong answer for the behavior of Ĥ ⟨Ĥ⟩.

The one that is not contradicted H ⟨Ĥ⟩ ⟨Ĥ⟩ get right answer from its POV
which is the also the right answer for the behavior of Ĥ ⟨Ĥ⟩.

--
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/8/24 9:55 PM, olcott wrote:
> On 3/8/2024 11:43 PM, Richard Damon wrote:
>> On 3/8/24 9:10 PM, olcott wrote:
>>> On 3/8/2024 10:58 PM, Richard Damon wrote:
>>>> On 3/8/24 8:45 PM, olcott wrote:
>>>>> On 3/8/2024 10:33 PM, Richard Damon wrote:
>>>>>> On 3/8/24 8:20 PM, olcott wrote:
>>>>>>> On 3/8/2024 9:41 PM, Richard Damon wrote:
>>>>>>>> On 3/8/24 7:06 PM, olcott wrote:
>>>>>>>>> Ĥ.H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> to Ĥ.Hqn
>>>>>>>>> therefore
>>>>>>>>> H computes the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ <H> to H.qy
>>>>>>>>>
>>>>>>>>> I still don't know the detailed steps of how
>>>>>>>>> H computes the mapping from ⟨H⟩ ⟨H⟩ <H> to H.qy
>>>>>>>>> YET WE CAN SEE THAT IT IS CORRECT
>>>>>>>>
>>>>>>>> No, you see that you have a set of results that makes
>>>>>>>
>>>>>>> Every H needs a criteria to use whether it is contradicted
>>>>>>> or not. When it is not contradicted this same criteria
>>>>>>> correctly decides halting for its input.
>>>>>>>
>>>>>>> When H is contradicted it provides a consistent way
>>>>>>> that H can provide the wrong answer.
>>>>>>
>>>>>> But if you admit that it will get a wrong answer, how can you
>>>>>> claim it is a correct Halt Decider, which means it always gets the
>>>>>> Right answer.
>>>>>>
>>>>>
>>>>> When the input data gets the wrong answer this allows the
>>>>> actual decider to get the right answer.
>>>>
>>>> But the algorith at H^.H IS an instanc eof the decide,r, and must
>>>> get the answer right.
>>>>
>>>> You are just admitting to being a STUPID LIAR.
>>>
>>>
>>> You are the one that does not understand that making changes to
>>> a machine to so it will not work properly does make this machine
>>> not work properly.
>>
>> What CHANGES have I been saying to make?
>>
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>
> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.

But that is the job it signed up for when it tried to call itself a Halt
Decider.

Remember, there is no actual requirement that we be able to tell in
finite time that a given calculation will eventually terminate. It
wouldbe a nice feature, but nothing says it is possible.

If you want to try to meet an impossible goal, that your problem.

Can be an interesting challange to TRY and do it, and get some
understanding of why it is hard, but saying something is wrong because
you can't do it has no grounds.

>
>> YOU need to define the details of the Algorithm that you will call H.
>>
>> You have full control over it, it just nedds to be actual Turing
>> Machine code, or code that is ACTUAL the equivalent of a Turing Machine.
>>
>> That means it is defined by what steps it does, and how it does it.
>> NOT "get such-and-such an answer".
>>
>> These are fixed deterministic steps.
>>
>> Once you do that, the Linz proof defines how to built the machine H^
>> by its SEMANTIC DEFINITION of H^ adjusts the tape so it can use an
>> exact copy of the algorithm of the H it is to confound, with exactly
>> the same inputs as that will have when answering about this H^ applied
>> to its input.
>>
>> We can the run your H with the description of that H^, and see what it
>> predicts H^ (H^) will do.
>>
>> We can also then run that H^ (H^) and see what it does.
>>
>> Because of the requirement that H be a computation, then the copy of H
>> at H^.H since it is given the exact same input as when we ran it
>> earlier, must give the exact same answer as it did above.
>>
>> We can then compare the results of what H said its input would do to
>> what the input actually did. If they match, it passed that test.
>>
>> If they differ, H was proven to not be a correct Halt Decider.
>>
>> Nowhere did we make "changes" to any machine to make it not work
>> properly. The algorithm you provided for H was exactly used to make H,
>> and to be put at H^.H.
>>
>> Remember, Machines are DEFINED by the algorithm they were defined
>> with, NOT the specification or requirements that algorithm was
>> supposed to meet. It is the creater of the Algorithms job to meet
>> that, and the algorithm will either acheive of fail at meeting the
>> reqquirements.
>>
>>>
>>>>>
>>>>>> You are just admitting that you are lying about refuting the proof
>>>>>> that we can not make an always correct Halt Decider.
>>>>>>
>>>>>> You don't get to claim to be right, when the machine gives the
>>>>>> wrong answer.
>>>>>>
>>>>>>>
>>>>>>> You already know that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ must be aborted by Ĥ.H
>>>>>>> or it will never halt.
>>>>>>>
>>>>>>> When every H has the same way to say that, then when it is
>>>>>>> contradicted it has something to say and when it is not
>>>>>>> contradicted this is the correct halt status of its input.
>>>>>>>
>>>>>>
>>>>>> No, if ANY copy of H gives the wrong answer to some input, then H
>>>>>> is not a Halt Decider.
>>>>>
>>>>> When the input data gets the wrong answer this allows the
>>>>> actual decider to get the right answer.
>>>>
>>>> And thus you admit that H is WRONG, as all copies of it are the
>>>> ACTUAL DECIDER.
>>>>
>>>
>>> I never said anything like that. I say that Ĥ.H and you twist
>>> this to man that I said H was wrong.
>>
>> Because the code at H^.H *IS* an instance of H.
>>
>
> H ⟨Ĥ⟩ ⟨Ĥ⟩ is not contradicted is not the same one
> that is contradicted Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩

Then you lied about build H^ by the definition.

To be a Decider, H needs to give the same answer every time it is given
the same set of inputs.

To be a Halt Decider, H's answer needs to match the Halting Behavior of
the computation described to it, WHATEVER that input happens to be (even
if it is contradictory to us).

This turns out to be impossible to do, because the Halting Property
creates a non-computable mapping.

One way this is shown is with the proof that Linz lays out, and the
specification for this particular input begins with starting with an
EXACT copy of the algorithm of our claimed Halt Decider, which BY
DEFINITION will act exactly like every other copy of this algorithm when
given the same input.

We then augment this algorithm, not changing its behavior from its start
to its decision, so the resulting machine does the opposite behavior to
what the decider says, and then configure to give the decider the exact
same input as it would have when someone asks it about this particular
input. That means that our copy of it, at H^.H WILL act exactly as the
copy that is directly asked about us, that is H (H^) (H^).

Thus, if H and H^.H are not the same algorithm getting the same data,
you did not build H^ to its specification, and thus are a LIAR.

So, why do you say they could be different?

Did you lie that you followed Linz?

Do you just not understand anything about this topic?

>
>> If it isn't, then you have been lying and I can't help you.
>>
>>>
>>>> That is the nature of a Computation.
>>>>
>>>> ANY instance of the algorithm applied to its input must get the same
>>>> answer for the same data and to be correct must match the mapping
>>>> that it is supposed to derive.
>>>>
>>>
>>> *Every H reports whether its input halts from its POV*
>>
>> It might HAVE to do that, but to meet its requirements it needs to
>> answer about the FACTUAL behavior of the computation its input defines.
>
> The one that is contradicted Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ gets right answer from its POV
> which is the wrong answer for the behavior of Ĥ ⟨Ĥ⟩.

On 3/9/2024 12:25 AM, Richard Damon wrote:
> On 3/8/24 9:55 PM, olcott wrote:
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>
>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> But that is the job it signed up for when it tried to call itself a Halt
> Decider.
>

There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
Therefore it must have a basis for its wrong answer.

--
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/8/24 10:40 PM, olcott wrote:
> On 3/9/2024 12:25 AM, Richard Damon wrote:
>> On 3/8/24 9:55 PM, olcott wrote:
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>
>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> But that is the job it signed up for when it tried to call itself a
>> Halt Decider.
>>
>
> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
> Therefore it must have a basis for its wrong answer.
>
>

WHY?

What is the actual grounds for that statement?

If it doesn't give the right answer, it just isn't a Halt Decider, and
thus isn't actually constrained by the definition of one.

H either IS or it IS NOT a Halt Decider. Being "close" doesn't make it one.

Once you admit it isn't going to be a Halt Decider, you need to admit
that and then decide what you are going to try to make it to meet your
need. (If you have one).

The original task for a Halt Decider was Theorem proving and Knowledge
gathering, where you needed to either be 100% accurate, or it didn't
help. (you don't prove a theorem with a 99% accuracy, only 100%)

For the goal you have stated, you also need 100% or you have nothing. If
you are willing to accept approximate and slightly flawed decisions, you
don't need to refute the Halting Theorem, as it alread allows for those
to exist.

Just like if you want to be able to refute most falsehood, you don't
need the Truth Predicate, as most major false statement are provably
false, (if the person will look at logic, and if not, having the
predicate wouldn't help anyway).

On 2024-03-08 21:34:30 +0000, olcott said:

> Olcott machines are fully specified. Some of the details of the
> exact steps that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> would use to detect that it must
> abort the simulation of it input to prevent is own infinite
> execution must be worked out.

What is the difference between ⟨Ĥ⟩ and <Ĥ> above and on the
subject line?

--
Mikko

On 8/03/24 20:17, olcott wrote:
> On 3/8/2024 12:40 PM, Richard Damon wrote:
>> On 3/8/24 10:11 AM, olcott wrote:

you are both replying to a thread that was obviously just a joke

On 8/03/24 21:29, Richard Damon wrote:
> On 3/8/24 11:17 AM, olcott wrote:
>> Olcott machines make it impossible for a machine to not
>> know its own machine description.
>
> It know *A* version of its machine description, not ALL of them (as that
> is an infinte amount of data)

A Turing machine description can be defined in a way where each machine
only has one description. There are an infinite number of different
machines which always compute the same answer as the first machine, however.

On 8/03/24 22:34, olcott wrote:
>> And since H^ can "lie" to that embedded H^.H about what its
>> description is, that H can't tell that it is part of an H^ computation
>> that is simulating an H^ computation.
>
> That subject must be postponed until after the Olcott refutation
> of the exact Linz proof is either fully accepted by three people
> or actual errors or gaps are found that cannot be addressed or
> corrected.

It's accepted that the Linz proof doen't work on Olcott machines because
the Linz proof is designed for Turing machines. But you can't refute the
Linz-immibis proof designed for Olcott machines, where H is lied to
about its own description.

On 3/9/2024 7:47 AM, immibis wrote:
> On 8/03/24 22:34, olcott wrote:
>>> And since H^ can "lie" to that embedded H^.H about what its
>>> description is, that H can't tell that it is part of an H^
>>> computation that is simulating an H^ computation.
>>
>> That subject must be postponed until after the Olcott refutation
>> of the exact Linz proof is either fully accepted by three people
>> or actual errors or gaps are found that cannot be addressed or
>> corrected.
>
> It's accepted that the Linz proof doen't work on Olcott machines because
> the Linz proof is designed for Turing machines. But you can't refute the
> Linz-immibis proof designed for Olcott machines, where H is lied to
> about its own description.

I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.

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

On 9/03/24 16:12, olcott wrote:
> On 3/9/2024 7:47 AM, immibis wrote:
>> On 8/03/24 22:34, olcott wrote:
>>>> And since H^ can "lie" to that embedded H^.H about what its
>>>> description is, that H can't tell that it is part of an H^
>>>> computation that is simulating an H^ computation.
>>>
>>> That subject must be postponed until after the Olcott refutation
>>> of the exact Linz proof is either fully accepted by three people
>>> or actual errors or gaps are found that cannot be addressed or
>>> corrected.
>>
>> It's accepted that the Linz proof doen't work on Olcott machines
>> because the Linz proof is designed for Turing machines. But you can't
>> refute the Linz-immibis proof designed for Olcott machines, where H is
>> lied to about its own description.
>
> I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except halt or fail to halt
> and H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> could see that.
>

I am not sure what Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do except for exactly the same
thing that H ⟨Ĥ⟩ ⟨Ĥ⟩ <H> would do.

On 3/9/2024 3:32 AM, Mikko wrote:
> On 2024-03-08 21:34:30 +0000, olcott said:
>
>> Olcott machines are fully specified. Some of the details of the
>> exact steps that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <Ĥ> would use to detect that it must
>> abort the simulation of it input to prevent is own infinite
>> execution must be worked out.
>
> What is the difference between ⟨Ĥ⟩ and <Ĥ> above and on the
> subject line?
>

We know in advance that every Turing Machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
is the correct answer when all simulating halt deciders would
correctly report on the behavior of their input from their own POV.

I created Olcott machines to make it easier to see how Ĥ.H would
do this. It may be the case that a Turing machine Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can
detect that it must abort its simulation, thus from its own POV
its input does not halt. For whatever reason that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn
H ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* H.qy would be correct.

Instead of Olcott machines we can simply hypothesize that
Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ is somehow able to detect that its input would not
halt from its own POV and thus must abort the simulation of
its input and transition to Ĥ.Hqn. This makes it obvious
that H ⟨Ĥ⟩ ⟨Ĥ⟩ has the basis to transition to H.qy.

This was not possible before the Olcott notion of simulating
halt deciders that correctly determine the halt status of their
inputs from their own POV. Previously Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ had no basis
to report anything. As soon as it does have some basis to report
something then H ⟨Ĥ⟩ ⟨Ĥ⟩ has the basis to decide halting.

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ and H ⟨Ĥ⟩ ⟨Ĥ⟩ must use the same basis.
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn // Ĥ applied to ⟨Ĥ⟩ does not halt

Execution trace of Ĥ applied to ⟨Ĥ⟩
(a) Ĥ.q0 The input ⟨Ĥ⟩ is copied then transitions to Ĥ.H
(b) Ĥ.H applied ⟨Ĥ⟩ ⟨Ĥ⟩ (input and copy) simulates ⟨Ĥ⟩ applied to ⟨Ĥ⟩
(c) which begins at its own simulated ⟨Ĥ.q0⟩ to repeat the process
*The same execution trace occurs even when the infinite loop is removed*

Proves that Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ must abort its simulation and thus transition
to Ĥ.Hqn. As long as Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ can somehow see this then H ⟨Ĥ⟩ ⟨Ĥ⟩
applies this same basis an transitions to H.qy

*Criterion Measure*
*Determine halt status from simulating halt deciders POV*
H is assumed to be a simulating termination analyzer that aborts the
simulation of any input that would cause its own non-termination and
returns NO. Otherwise H always returns YES.

--
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/9/2024 1:05 AM, Richard Damon wrote:
> On 3/8/24 10:40 PM, olcott wrote:
>> On 3/9/2024 12:25 AM, Richard Damon wrote:
>>> On 3/8/24 9:55 PM, olcott wrote:
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* ⊢* Ĥ.Hqy ∞ // Ĥ applied to ⟨Ĥ⟩ halts
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.Hq0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.Hqn   // Ĥ applied to ⟨Ĥ⟩ does not halt
>>>>
>>>> Expecting Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ to correctly report on the behavior of
>>>> Ĥ ⟨Ĥ⟩ is a little nuts because Ĥ contradicts Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> But that is the job it signed up for when it tried to call itself a
>>> Halt Decider.
>>>
>>
>> There is no correct answer that Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ can possibly
>> provide that corresponds to the behavior of this Ĥ ⟨Ĥ⟩.
>> Therefore it must have a basis for its wrong answer.
>>
>>
>
> WHY?
>
> What is the actual grounds for that statement?

Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ cannot just sit around scratching its head it
must do something. As soon as we have the basis for what
it will do, then H ⟨Ĥ⟩ ⟨Ĥ⟩ has its basis to correctly
decide halting.

All of the following that you said simply proves that you are
not paying close enough attention.

No one gives a rat's as that the input gets the wrong answer
as long as H ⟨Ĥ⟩ ⟨Ĥ⟩ has some basis to get the right answer.

>
> If it doesn't give the right answer, it just isn't a Halt Decider, and
> thus isn't actually constrained by the definition of one.
>
> H either IS or it IS NOT a Halt Decider. Being "close" doesn't make it one.
>
> Once you admit it isn't going to be a Halt Decider, you need to admit
> that and then decide what you are going to try to make it to meet your
> need. (If you have one).
>
> The original task for a Halt Decider was Theorem proving and Knowledge
> gathering, where you needed to either be 100% accurate, or it didn't
> help. (you don't prove a theorem with a 99% accuracy, only 100%)
>
> For the goal you have stated, you also need 100% or you have nothing. If
> you are willing to accept approximate and slightly flawed decisions, you
> don't need to refute the Halting Theorem, as it alread allows for those
> to exist.
>
> Just like if you want to be able to refute most falsehood, you don't
> need the Truth Predicate, as most major false statement are provably
> false, (if the person will look at logic, and if not, having the
> predicate wouldn't help anyway).

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