On 3/6/22 7:53 PM, olcott wrote:
> On 3/6/2022 6:21 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/6/2022 11:36 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/5/2022 2:38 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/4/2022 5:37 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> When a sequence of configurations would never reach their final
>>>>>>>>> state
>>>>>>>>> in any finite number of steps of pure simulation then this
>>>>>>>>> sequence of
>>>>>>>>> configurations specify non-halting behavior.
>>>>>>>>
>>>>>>>> This is the halting problem.  It is better expressed in the simpler
>>>>>>>> terms given in texts like Linz.  I don't like the wording, just
>>>>>>>> gives
>>>>>>>> the gist.
>>>>>>>
>>>>>>> OK good so far.
>>>>>>>
>>>>>>>>> The criterion measure shown below defines the set of
>>>>>>>>> configurations
>>>>>>>>> that never reach their final state.
>>>>>>>>>
>>>>>>>>> Simple English version of Olcott's Halt status criterion measure:
>>>>>>>>> Every simulating halt decider that must abort the simulation of
>>>>>>>>> its
>>>>>>>>> input to prevent its infinite simulation correctly transitions
>>>>>>>>> to its
>>>>>>>>> reject state.
>>>>>>>>
>>>>>>>> This is not the halting problem.  Its even more badly written
>>>>>>>> than the
>>>>>>>> first (for example, it's circular, and uses undefined metaphors
>>>>>>>> like
>>>>>>>> "abort") but it conveys enough for readers to know that it's not
>>>>>>>> the
>>>>>>>> correct criterion for the halting problem.  It's this "Halt status
>>>>>>>> criterion measure" (pompous or what?) that permits your decider to
>>>>>>>> reject a string that represents a halting computation.
>>>>>>>
>>>>>>> When a simulating halt decider correctly determines its correctly
>>>>>>> simulated input would never reach its final state in any finite
>>>>>>> number
>>>>>>> of steps of pure simulation then this simulating halt decider has
>>>>>>> correctly determined that this input specifies non-halting behavior.
>>>>>> There is no such thing as a simulating halt decider because there
>>>>>> are no
>>>>>> halt deciders at all.
>>>>>
>>>>> Then call it a halt determiner.
>>>> What they are called is not really very important.  What they do is
>>>> crucial.
>>>>
>>>>>>    But we can find out what you are saying about
>>>>>> these things asking if a TM, any TM, can do what you say:
>>>>>>
>>>>>> When a TM (any TM) correctly determines its correctly simulated input
>>>>>> would never reach its final state in any finite number of steps of
>>>>>> pure
>>>>>> simulation then this TM has correctly determined that this input
>>>>>> specifies non-halting behavior.
>>>>>>
>>>>>> And re-worded again using tighter language and without all the filler
>>>>>> words:
>>>>>>
>>>>>> When a TM determines that a simulation of its input would not halt it
>>>>>> can correctly report that the input represents a non-halting
>>>>>> computation.
>>>>>
>>>>> Not precise enough. It must be a simulation performed by the
>>>>> simulating halt determiner.
>>>>
>>>> Ah, then you need to define what that is.  If it's different to a
>>>> simulator in any significant way then your statements is not about the
>>>> halting problem and can be ignored.
>>
>> This is me pointing out a mistake which you are, as usual, ignoring.
>> Soon you will say, again, that no one can point out any errors in what
>> you say.
>>
>
> Since I have defined it 10,000 times it seems a little nuts that you ask
> me to define it again. I have defined it again below.
>
>>>>> When a TM determines that [its correct pure] simulation of its input
>>>>> would not halt it can correctly report that the input represents a
>>>>> non-halting computation.
>>>>
>>>> This is either the same as my re-write (if you remove the [...] part or
>>>> replace "its" with "a") or it is an attempt to obscure the that fact
>>>> that the "determiner" can ignore some halting computations because "it"
>>>> halted them.  I am sure it the latter this as been you ruse for ages.
>>>> Anyway, you should either write the correct condition as found in every
>>>> textbook you've never read, or just come clean that you are not talking
>>>> about the halting problem.
>>
>> This is me pointing out another two mistakes which you are, as usual,
>> ignoring.  Soon you will say, again, that no one can point out any
>> errors in what you say.
>>
>
> When-so-ever a simulating halt determiner detects an infinite behavior
> pattern in the simulation of its input such that this simulated input
> would never reach its final state in any finite number of steps it
> rejects this input.
>

IF it can correctly detect that an actual UTM simulating this input
would never halt, then it would be correct.

If that actual UTM simulation (and not the simulation by the 'plays one
on TV, H') does halt, then H was incorrect.

Note again. If H appied to <H^> <H^> -> H.Qn then it is a demonstratable
fact that H^ applied to <H^> <H^> will -> H^.Qn and Halt, and thus UTM
applied to <H^> <H^> will go to H^.Qn and Halt, so H was wrong.

BY DEFINITION.

You comments that say otherwise are just blatent LIES.

>>>>> Your definition will be to confusing for people that are not computer
>>>>> scientists because they will believe that when the simulating halt
>>>>> determiner aborts its simulation that this causes the input to halt,
>>>>> thus the halt determiner is contradicting itself.
>>>> My definition did not use undefined terms like "simulating halt
>>>> determiner" or "abort".  And mine had no absurd vague "its" in it.
>>
>> And this is me pointing out yet another mistake which you are, as usual,
>> ignoring.  Soon you will say, again, that no one can point out any
>> errors in what you say.
>
>
> It is freaking nuts to require "simulation has been aborted" to be defined.
>
>>
>>>>>> And even more simply (and obviously):
>>>>>> When a TM determines that its input represents a non-halting
>>>>>> computation
>>>>>> it can correct report that the input represents a non-halting
>>>>>> computation.
>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> Of course you miss of the key conditions because you have not yet found
>>>> a way to write the that fools anyone:
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞  if Ĥ halts on input ⟨Ĥ⟩, and
>>>>     Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn    if Ĥ does not halts on input
>>>> ⟨Ĥ⟩.
>>>>
>>>>> Could a correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H transition to
>>>>> ⟨Ĥ⟩.qn ?
>>>> Who knows?  You have not defined what ⟨Ĥ⟩.qn means.
>>
>> And this is me pointing out yet another mistake which you are, as usual,
>> ignoring.  Soon you will say, again, that no one can point out any
>> errors in your reasoning.
>
> When this simulated input ⟨Ĥ⟩ ⟨Ĥ⟩ has reached its own final state this
> final state is referred to as ⟨Ĥ⟩.qn.

I'm getting bored so I will skip to the chase at the end..

olcott <NoOne@NoWhere.com> writes:

> On 3/6/2022 6:21 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:

>>> A halt determiner is the same thing as a halt decider with the only
>>> difference being that the halt determiner needs to only correctly
>>> determine the halt status of a single input pair or a limited set of
>>> input pairs thus has a restricted domain.
>>
>> Then, for every single "input pair", there are an infinity of correct
>> "halt determiners". No one is interested in such trivial things.
>>
>> You will probably be baffled by how I can say this, but I bet that, if
>> your are, you won't try to find out by trying to learn something.
>>
>>> A simulating halt determiner determines whether or not its input
>>> specifies a non-halting sequence of configurations on the basis of
>>> recognizing infinite patterns in the behavior of its simulated input
>>> (such as the above pattern) that indicate that it would never reach
>>> its final state in any finite number of steps of pure simulation.
>>
>> That's one way to write some of these trivial Turing machines. I still
>> don't care about them.
>
> The simulating halt determiner that decides halting for the Linz Ĥ
> defeats his proof.

No. You have not noticed what you have actually said, have you?

>>>> Why should anyone care?
>>>
>>> Thus the copy of Linz H embedded at Ĥ.qx correctly determines that its
>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thereby refuting the Linz proof that this
>>> is impossible.
>>
>> Linz's H does not exist. There is no input string ⟨Ĥ⟩ ⟨Ĥ⟩. There is a
>> proof about that. There are lots of proofs about that.
>> Your H may exist, but it's not Linz's.
>
> As long as the Linz Ĥ relationship to its halt determiner is
> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
> halts defeats the Linz proof.

Not "any damn thing", no. It must be the supposed halt determiner, H,
that correctly determines it. Now that might be what you are trying to
so say with the mysterious "its", but then putting in "any damn thing"
is just daft.

More clearly, if you have an TM H such that either

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,

or

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,

then you will have done the impossible thing what you claimed to have
done more than three years ago.

Bit to find "any damn thing" (i.e. not H itself) that correctly
determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never halts is not in the least bit interesting.
It's what you were talking about above without realising it. There are
loads of TMs such that

X.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* X.qn when Ĥ does not halt on input ⟨Ĥ⟩.

It's getting H to do this for a correctly constructed ⟨Ĥ⟩ ⟨Ĥ⟩ that's
impossible.

--
Ben.

On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
> I'm getting bored so I will skip to the chase at the end..
>
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/6/2022 6:21 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> A halt determiner is the same thing as a halt decider with the only
>>>> difference being that the halt determiner needs to only correctly
>>>> determine the halt status of a single input pair or a limited set of
>>>> input pairs thus has a restricted domain.
>>>
>>> Then, for every single "input pair", there are an infinity of correct
>>> "halt determiners". No one is interested in such trivial things.
>>>
>>> You will probably be baffled by how I can say this, but I bet that, if
>>> your are, you won't try to find out by trying to learn something.
>>>
>>>> A simulating halt determiner determines whether or not its input
>>>> specifies a non-halting sequence of configurations on the basis of
>>>> recognizing infinite patterns in the behavior of its simulated input
>>>> (such as the above pattern) that indicate that it would never reach
>>>> its final state in any finite number of steps of pure simulation.
>>>
>>> That's one way to write some of these trivial Turing machines. I still
>>> don't care about them.
>>
>> The simulating halt determiner that decides halting for the Linz Ĥ
>> defeats his proof.
>
> No. You have not noticed what you have actually said, have you?
>
>>>>> Why should anyone care?
>>>>
>>>> Thus the copy of Linz H embedded at Ĥ.qx correctly determines that its
>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thereby refuting the Linz proof that this
>>>> is impossible.
>>>
>>> Linz's H does not exist. There is no input string ⟨Ĥ⟩ ⟨Ĥ⟩. There is a
>>> proof about that. There are lots of proofs about that.
>>> Your H may exist, but it's not Linz's.
>>
>> As long as the Linz Ĥ relationship to its halt determiner is
>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>> halts defeats the Linz proof.
>
> Not "any damn thing", no. It must be the supposed halt determiner, H,
> that correctly determines it. Now that might be what you are trying to
> so say with the mysterious "its", but then putting in "any damn thing"
> is just daft.
>
> More clearly, if you have an TM H such that either
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>
> or
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>
> then you will have done the impossible thing what you claimed to have
> done more than three years ago.
>
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

When Ĥ is applied to ⟨Ĥ⟩
Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩

Then these steps would keep repeating:
Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

Because the pure simulation of the ⟨Ĥ⟩ ⟨Ĥ⟩ input to the simulating halt
determiner at Ĥ.qx would never reach its own final state of ⟨Ĥ⟩.qn in
any finite number of steps this input is correctly rejected.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/6/22 10:16 PM, olcott wrote:
> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>> I'm getting bored so I will skip to the chase at the end..
>>
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/6/2022 6:21 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> A halt determiner is the same thing as a halt decider with the only
>>>>> difference being that the halt determiner needs to only correctly
>>>>> determine the halt status of a single input pair or a limited set of
>>>>> input pairs thus has a restricted domain.
>>>>
>>>> Then, for every single "input pair", there are an infinity of correct
>>>> "halt determiners".  No one is interested in such trivial things.
>>>>
>>>> You will probably be baffled by how I can say this, but I bet that, if
>>>> your are, you won't try to find out by trying to learn something.
>>>>
>>>>> A simulating halt determiner determines whether or not its input
>>>>> specifies a non-halting sequence of configurations on the basis of
>>>>> recognizing infinite patterns in the behavior of its simulated input
>>>>> (such as the above pattern) that indicate that it would never reach
>>>>> its final state in any finite number of steps of pure simulation.
>>>>
>>>> That's one way to write some of these trivial Turing machines.  I still
>>>> don't care about them.
>>>
>>> The simulating halt determiner that decides halting for the Linz Ĥ
>>> defeats his proof.
>>
>> No.  You have not noticed what you have actually said, have you?
>>
>>>>>> Why should anyone care?
>>>>>
>>>>> Thus the copy of Linz H embedded at Ĥ.qx correctly determines that its
>>>>> input: ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thereby refuting the Linz proof that this
>>>>> is impossible.
>>>>
>>>> Linz's H does not exist.  There is no input string ⟨Ĥ⟩ ⟨Ĥ⟩.  There is a
>>>> proof about that.  There are lots of proofs about that.
>>>> Your H may exist, but it's not Linz's.
>>>
>>> As long as the Linz Ĥ relationship to its halt determiner is
>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>> halts defeats the Linz proof.
>>
>> Not "any damn thing", no.  It must be the supposed halt determiner, H,
>> that correctly determines it.  Now that might be what you are trying to
>> so say with the mysterious "its", but then putting in "any damn thing"
>> is just daft.
>>
>> More clearly, if you have an TM H such that either
>>
>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>
>> or
>>
>>    H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>
>> then you will have done the impossible thing what you claimed to have
>> done more than three years ago.
>>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When Ĥ is applied to ⟨Ĥ⟩
>   Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
>   Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>   Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>   Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> Because the pure simulation of the ⟨Ĥ⟩ ⟨Ĥ⟩ input to the simulating halt
> determiner at Ĥ.qx would never reach its own final state of ⟨Ĥ⟩.qn in
> any finite number of steps this input is correctly rejected.
>

Which only happens if H is DEFINED to NEVER Abort.

In that case, H will never answer, so it NEVER rejected.

Change H to abort/reject, and H^ will then be changed, and the pattern
doesn't occur, and the proof is invalid.

You need the mythical Fairy Dust Powered Unicorn that can be two
different Turing Machines at the same time to do what you claim.

That, or you are lying that H^ is built from the H that you are claiming
is getting the right answer.

FAIL.

Maybe your problem is that you have your H spend an infinite time in the
loop (to make H^ non-halting) and then it goes back in time and answers
in an alternate reality.

That's not allowed either, H needs to answer in finite time, but you
don't seem to understand how infinity works.

olcott <NoOne@NoWhere.com> writes:

> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>> I'm getting bored so I will skip to the chase at the end..
>> olcott <NoOne@NoWhere.com> writes:

>>> As long as the Linz Ĥ relationship to its halt determiner is
>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>> halts defeats the Linz proof.
>>
>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>> that correctly determines it. Now that might be what you are trying to
>> so say with the mysterious "its", but then putting in "any damn thing"
>> is just daft.
>>
>> More clearly, if you have an TM H such that either
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>> or
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>> then you will have done the impossible thing what you claimed to have
>> done more than three years ago.
>>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> When Ĥ is applied to ⟨Ĥ⟩
> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>
> Then these steps would keep repeating:
> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...

So, just to be 100% clear, you are /not/ claiming to have an TM that
does either

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
or
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩

You did once and, since it's impossible, it hooked people in.

--
Ben.

On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>> I'm getting bored so I will skip to the chase at the end..
>>> olcott <NoOne@NoWhere.com> writes:
>
>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>> halts defeats the Linz proof.
>>>
>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>> that correctly determines it. Now that might be what you are trying to
>>> so say with the mysterious "its", but then putting in "any damn thing"
>>> is just daft.
>>>
>>> More clearly, if you have an TM H such that either
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>> or
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>> then you will have done the impossible thing what you claimed to have
>>> done more than three years ago.
>>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> When Ĥ is applied to ⟨Ĥ⟩
>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>
>> Then these steps would keep repeating:
>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>
> So, just to be 100% clear, you are /not/ claiming to have an TM that
> does either
>

What I am claiming is that the above shows that if embedded_H rejected
its input it would be correct.

Because the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
reach its own final state of ⟨Ĥ⟩.qn in any finite number of steps of
simulation embedded_H would be correct to reject its input: ⟨Ĥ⟩ ⟨Ĥ⟩

> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
> or
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩
>
> You did once and, since it's impossible, it hooked people in.

I have not been talking about H for many months. I have been talking
about the simulating halt determiner at Ĥ.qx that I refer to as embedded_H.

https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

olcott <NoOne@NoWhere.com> writes:

> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>> I'm getting bored so I will skip to the chase at the end..
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>> halts defeats the Linz proof.
>>>>
>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>> that correctly determines it. Now that might be what you are trying to
>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>> is just daft.
>>>>
>>>> More clearly, if you have an TM H such that either
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>> or
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>> then you will have done the impossible thing what you claimed to have
>>>> done more than three years ago.
>>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> Then these steps would keep repeating:
>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>
>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>> does either
>
> What I am claiming is that the above shows that if embedded_H rejected
> its input it would be correct.

So what? We are interested in the halting problem and your claim to
have addressed the key case: to have an H such that either

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
or
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩.

But you don't. You have some other H (and hence some other embedded_H
and some other Ĥ and ⟨Ĥ⟩ ⟨Ĥ⟩) about which we don't care.

>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>> or
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩
>> You did once and, since it's impossible, it hooked people in.
>
> I have not been talking about H for many months.

Of course. Your H is junk. You must avoid talking about it at all
costs. Not talking about it does not make it, or the criticisms of it,
go away.

Anyway, one thing is clear from your non-answer. You are no longer
claiming to have anything like the impossible TM you once claimed to
have. You have something that does something with some input that is
not Linz's H. Well, that's thrilling (not).

--
Ben.

On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>> halts defeats the Linz proof.
>>>>>
>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>> that correctly determines it. Now that might be what you are trying to
>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>> is just daft.
>>>>>
>>>>> More clearly, if you have an TM H such that either
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>> or
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>> then you will have done the impossible thing what you claimed to have
>>>>> done more than three years ago.
>>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>
>>>> Then these steps would keep repeating:
>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>
>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>> does either
>>
>> What I am claiming is that the above shows that if embedded_H rejected
>> its input it would be correct.
>
> So what? We are interested in the halting problem and your claim to
> have addressed the key case: to have an H such that either
>

The copy of Linz H embedded at Ĥ.qx would correctly decide that its
input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this is
impossible.

https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
in a finite number of steps.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
state in any finite number of steps.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

olcott <NoOne@NoWhere.com> writes:

> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>> halts defeats the Linz proof.
>>>>>>
>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>> is just daft.
>>>>>>
>>>>>> More clearly, if you have an TM H such that either
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>> or
>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>> done more than three years ago.
>>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>
>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>
>>>>> Then these steps would keep repeating:
>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>
>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>> does either
>>>
>>> What I am claiming is that the above shows that if embedded_H rejected
>>> its input it would be correct.
>>
>> So what? We are interested in the halting problem and your claim to
>> have addressed the key case: to have an H such that either
>
> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
> is impossible.

No. Linz's H is such that neither

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
nor
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,

is possible.

> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
> in a finite number of steps.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
> state in any finite number of steps.

Still don't care about this H of yours. You hooked people in with a lie
that you kept repeating: your H is Linz's H. At least you've come clean
now and are attempting a hand-waving definition of your H.

--
Ben.

On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>> halts defeats the Linz proof.
>>>>>>>
>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>> is just daft.
>>>>>>>
>>>>>>> More clearly, if you have an TM H such that either
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>> or
>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>> done more than three years ago.
>>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>
>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>
>>>>>> Then these steps would keep repeating:
>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>
>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>> does either
>>>>
>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>> its input it would be correct.
>>>
>>> So what? We are interested in the halting problem and your claim to
>>> have addressed the key case: to have an H such that either
>>
>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>> is impossible.
>
> No. Linz's H is such that neither
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
> nor
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>
> is possible.
>

Like I said I am not talking about H.
I have not been talking about H for many months.

Also the key thing that you make sure to ignore is that it is never the
case that any decider reports on the behavior of the computation that
contains itself. Decider's are not capable of reporting on the behavior
of Turing machines they can only accept or reject finite string inputs.

>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
>> in a finite number of steps.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
>> state in any finite number of steps.
>
> Still don't care about this H of yours. You hooked people in with a lie
> that you kept repeating: your H is Linz's H. At least you've come clean
> now and are attempting a hand-waving definition of your H.
>

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

olcott <NoOne@NoWhere.com> writes:

> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>
>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>> is just daft.
>>>>>>>>
>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>> or
>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>> done more than three years ago.
>>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>
>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>
>>>>>>> Then these steps would keep repeating:
>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>
>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>> does either
>>>>>
>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>> its input it would be correct.
>>>>
>>>> So what? We are interested in the halting problem and your claim to
>>>> have addressed the key case: to have an H such that either
>>>
>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>> is impossible.
>> No. Linz's H is such that neither
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>> nor
>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>> is possible.
>
> Like I said I am not talking about H.
> I have not been talking about H for many months.

There's no need to keep repeating that. I understand 100% that you are
not talking about, and don't want to talk about, your H.

If you really don't want to talk about your H, don't reply. I'll say
what I like about it in peace. But you can't offer any response to my
posts about it if you won't talk about it.

> Also the key thing that you make sure to ignore is that it is never
> the case that any decider reports on the behavior of the computation
> that contains itself. Decider's are not capable of reporting on the
> behavior of Turing machines they can only accept or reject finite
> string inputs.

I don't ignore it, I tell you that you are wrong -- every time you bring
it up. What's more, I have, on multiple occasions, said that I can
offer you a series of exercises that, if you were to take them
seriously, might lead you to see why you are wrong.

This is one of your favourite themes. You accuse people of ignoring
something that they have answered every time you bring it up. But,
unlike a crank, I will answer it every time you ask: you are wrong. Of
course deciders are capable of reporting on the behaviour of Turing
machines.

>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
>>> in a finite number of steps.
>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
>>> state in any finite number of steps.
>>
>> Still don't care about this H of yours. You hooked people in with a lie
>> that you kept repeating: your H is Linz's H. At least you've come clean
>> now and are attempting a hand-waving definition of your H.

So the situation is that no one cares about your H and you dare not talk
about it! There is nothing substantive to discuss if you won't talk
about the big mistakes.

--
Ben.

On 07/03/2022 22:13, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>
>>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>>> is just daft.
>>>>>>>>>
>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>> or
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>>> done more than three years ago.
>>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>
>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>>> does either
>>>>>>
>>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>>> its input it would be correct.
>>>>>
>>>>> So what? We are interested in the halting problem and your claim to
>>>>> have addressed the key case: to have an H such that either
>>>>
>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>> is impossible.
>>> No. Linz's H is such that neither
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>> nor
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>> is possible.
>>
>> Like I said I am not talking about H.
>> I have not been talking about H for many months.
>
> There's no need to keep repeating that. I understand 100% that you are
> not talking about, and don't want to talk about, your H.

When PO says "not talking about H" does that mean "not talking about PO's H" as you're thinking, or
does it mean "not talking about Linz's H - I'm talking about Linz's Ĥ which contains a /copy/ of H
that I'm calling embedded_H" ?

Yes of course embedded_H in Ĥ performs exactly the same computation on input (Ĥ,Ĥ) as H performs, up
to and including reaching the corresponding qy/qn state, so talking about Ĥ and the behaviour of
embedded_H is /indirectly/ talking about the behaviour of H - but, hey, we all know what PO's like...

(And also, you've said "I know you're not talking about /your/ H" several times, so if that wasn't
what PO meant, he would surely have picked up on that and corrected the misunderstanding. But, hey,
we all know what PO's like...)

Just wondering.

Mike.

Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:

> On 07/03/2022 22:13, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>
>>>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>>>> is just daft.
>>>>>>>>>>
>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>> or
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>>>> done more than three years ago.
>>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>
>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>>>> does either
>>>>>>>
>>>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>>>> its input it would be correct.
>>>>>>
>>>>>> So what? We are interested in the halting problem and your claim to
>>>>>> have addressed the key case: to have an H such that either
>>>>>
>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>>> is impossible.
>>>> No. Linz's H is such that neither
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>> nor
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>> is possible.
>>>
>>> Like I said I am not talking about H.
>>> I have not been talking about H for many months.
>> There's no need to keep repeating that. I understand 100% that you are
>> not talking about, and don't want to talk about, your H.
>
> When PO says "not talking about H" does that mean "not talking about
> PO's H" as you're thinking, or does it mean "not talking about Linz's
> H - I'm talking about Linz's Ĥ which contains a /copy/ of H that I'm
> calling embedded_H" ?

I think it's both. He's walking a tightrope: if it is too obvious that
what he calls H is not Linz's H, the game will be up. But if he is
explicit that he means H as Linz does, the game is also up!

> Yes of course embedded_H in Ĥ performs exactly the same computation on
> input (Ĥ,Ĥ) as H performs, up to and including reaching the
> corresponding qy/qn state, so talking about Ĥ and the behaviour of
> embedded_H is /indirectly/ talking about the behaviour of H - but,
> hey, we all know what PO's like...

Well sure. But it's simpler for me just to say "so you won't talk about
the big mistake" than to make that point. Especially as PO did, for a
while, deny that H and embedded_H went through the same state
transitions, and he may feel forced to try that on again.

This was manifest in various bits of nonsense. For example:

"When it is construed as input to H then ⟨Ĥ⟩ ⟨Ĥ⟩ encodes a halting
computation.

When it is construed as input to Ĥ.qx then ⟨Ĥ⟩ ⟨Ĥ⟩ DOES NOT encode a
halting computation."

and

"The copy of H at Ĥ.qx correctly decides that its input never halts.
H applied to ⟨Ĥ⟩ ⟨Ĥ⟩ correctly decides that its input halts."

and even more explicitly

"Ĥ.qx maps ⟨Ĥ⟩ ⟨Ĥ⟩ to Ĥ.qn
H maps ⟨Ĥ⟩ ⟨Ĥ⟩ to H.qy"

> (And also, you've said "I know you're not talking about /your/ H"
> several times, so if that wasn't what PO meant, he would surely have
> picked up on that and corrected the misunderstanding. But, hey, we
> all know what PO's like...)

Very often he does not know what he is saying. He'll write the magic
criterion in terms of a simulator, but in such a way that it's just
Linz's H. Then, in the same post, he'll write it again with some tiny
change in the wording which happens to make it "his H" -- the one that
is permitted to reject a halting computation because that computation
only halts because it was halted.

--
Ben.

On 3/7/2022 4:13 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>
>>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>>> is just daft.
>>>>>>>>>
>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>> or
>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>>> done more than three years ago.
>>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>
>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>
>>>>>>>> Then these steps would keep repeating:
>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>
>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>>> does either
>>>>>>
>>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>>> its input it would be correct.
>>>>>
>>>>> So what? We are interested in the halting problem and your claim to
>>>>> have addressed the key case: to have an H such that either
>>>>
>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>> is impossible.
>>> No. Linz's H is such that neither
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>> nor
>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>> is possible.
>>
>> Like I said I am not talking about H.
>> I have not been talking about H for many months.
>
> There's no need to keep repeating that. I understand 100% that you are
> not talking about, and don't want to talk about, your H.
>
> If you really don't want to talk about your H, don't reply. I'll say
> what I like about it in peace. But you can't offer any response to my
> posts about it if you won't talk about it.
>

I am only talking about the simulating halt decider that is embedded in
the middle of the Linz Ĥ at Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

>> Also the key thing that you make sure to ignore is that it is never
>> the case that any decider reports on the behavior of the computation
>> that contains itself. Decider's are not capable of reporting on the
>> behavior of Turing machines they can only accept or reject finite
>> string inputs.
>
> I don't ignore it, I tell you that you are wrong -- every time you bring
> it up. What's more, I have, on multiple occasions, said that I can
> offer you a series of exercises that, if you were to take them
> seriously, might lead you to see why you are wrong.
>
> This is one of your favourite themes. You accuse people of ignoring
> something that they have answered every time you bring it up. But,
> unlike a crank, I will answer it every time you ask: you are wrong. Of
> course deciders are capable of reporting on the behaviour of Turing
> machines.
>
>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
>>>> in a finite number of steps.
>>>>
>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
>>>> state in any finite number of steps.
>>>
>>> Still don't care about this H of yours. You hooked people in with a lie
>>> that you kept repeating: your H is Linz's H. At least you've come clean
>>> now and are attempting a hand-waving definition of your H.
>
> So the situation is

That you cannot pay attention to the fact that when the simulating halt
decider embedded within Linz Ĥ at Ĥ.qx would reject its input it would
be correct and refute the Linz proof.

https://www.liarparadox.org/Linz_Proof.pdf

> that no one cares about your H and you dare not talk
> about it! There is nothing substantive to discuss if you won't talk
> about the big mistakes.
>

This is verbatim Linz except it has been adapted to my clearer
notational conventions:

<Linz quote>
Now Ĥ is a Turing machine, so that it will have some description in
Σ*, say ⟨Ĥ⟩. This string, in addition to being the description of Ĥ can
also be used as input string. We can therefore legitimately ask what
would happen if Ĥ is applied to ⟨Ĥ⟩.

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞

if Ĥ applied to ⟨Ĥ⟩ halts, and

Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn

if Ĥ applied to ⟨Ĥ⟩ does not halt. This is clearly nonsense. The
contradiction tells us that our assumption of the existence of H, and
hence the assumption of the decidability of the halting problem, must be
false.
</Linz quote>

The copy of Linz H embedded at Ĥ.qx will be referred to as embedded_H

Linz is confused into believing that embedded_H is reporting on the
behavior of the computation that contains itself Ĥ applied to ⟨Ĥ⟩,
rather than the behavior specified by its input: ⟨Ĥ⟩, ⟨Ĥ⟩.

THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS
THE KEY THING THAT YOU KEEP IGNORING IS

It is never the case that any decider reports on the behavior of the
computation that contains itself. Deciders are not capable of reporting
on the behavior of Turing machines they can only accept or reject finite
string inputs.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/7/2022 5:05 PM, Ben Bacarisse wrote:
> Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
>
>> On 07/03/2022 22:13, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>>
>>>>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>>>>> is just daft.
>>>>>>>>>>>
>>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>>> or
>>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>>>>> done more than three years ago.
>>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>
>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>
>>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>>>>> does either
>>>>>>>>
>>>>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>>>>> its input it would be correct.
>>>>>>>
>>>>>>> So what? We are interested in the halting problem and your claim to
>>>>>>> have addressed the key case: to have an H such that either
>>>>>>
>>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>>>> is impossible.
>>>>> No. Linz's H is such that neither
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>> nor
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>> is possible.
>>>>
>>>> Like I said I am not talking about H.
>>>> I have not been talking about H for many months.
>>> There's no need to keep repeating that. I understand 100% that you are
>>> not talking about, and don't want to talk about, your H.
>>
>> When PO says "not talking about H" does that mean "not talking about
>> PO's H" as you're thinking, or does it mean "not talking about Linz's
>> H - I'm talking about Linz's Ĥ which contains a /copy/ of H that I'm
>> calling embedded_H" ?
>
> I think it's both. He's walking a tightrope: if it is too obvious that
> what he calls H is not Linz's H, the game will be up. But if he is
> explicit that he means H as Linz does, the game is also up!
>

The only difference between embedded_H and a copy of the Linz H is that
embedded_H is not an ALL KNOWING halt decider it is merely a simulating
halt determiner that correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never
halts, thus refuting the Linz proof that says this is impossible.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer

On 3/7/22 10:14 AM, olcott wrote:
> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>> I'm getting bored so I will skip to the chase at the end..
>>>> olcott <NoOne@NoWhere.com> writes:
>>
>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>> halts defeats the Linz proof.
>>>>
>>>> Not "any damn thing", no.  It must be the supposed halt determiner, H,
>>>> that correctly determines it.  Now that might be what you are trying to
>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>> is just daft.
>>>>
>>>> More clearly, if you have an TM H such that either
>>>>     H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>> or
>>>>     H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>>> then you will have done the impossible thing what you claimed to have
>>>> done more than three years ago.
>>>>
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> When Ĥ is applied to ⟨Ĥ⟩
>>>    Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>
>>> Then these steps would keep repeating:
>>>    Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>    Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>    Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩
>>> ⟨Ĥ5⟩...
>>
>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>> does either
>>
>
> What I am claiming is that the above shows that if embedded_H rejected
> its input it would be correct.
>
> Because the correct pure simulation of ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never
> reach its own final state of ⟨Ĥ⟩.qn in any finite number of steps of
> simulation embedded_H would be correct to reject its input: ⟨Ĥ⟩ ⟨Ĥ⟩

Except that embedded_H CAN'T do a 'correct' simulation of its input if
it aborts it, especially if it 'simulates' its input assuming that
copies of embedded_H won't abort their simulation.

FAIL.

>
>>      H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>> or
>>      H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩
>>
>> You did once and, since it's impossible, it hooked people in.
>
> I have not been talking about H for many months. I have been talking
> about the simulating halt determiner at Ĥ.qx that I refer to as embedded_H.

Which IS H, or you are lying about building H^ by the rules.

Calling the copy of H by a different name, doesn't change anything about it.

>
> https://www.researchgate.net/publication/358009319_Halting_problem_undecidability_and_infinitely_nested_simulation_V3
>
>

On 3/7/22 6:07 PM, olcott wrote:
> On 3/7/2022 4:13 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩
>>>>>>>>>>> ⟨Ĥ⟩ never
>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>
>>>>>>>>>> Not "any damn thing", no.  It must be the supposed halt
>>>>>>>>>> determiner, H,
>>>>>>>>>> that correctly determines it.  Now that might be what you are
>>>>>>>>>> trying to
>>>>>>>>>> so say with the mysterious "its", but then putting in "any
>>>>>>>>>> damn thing"
>>>>>>>>>> is just daft.
>>>>>>>>>>
>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>>        H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>> or
>>>>>>>>>>        H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>>> then you will have done the impossible thing what you claimed
>>>>>>>>>> to have
>>>>>>>>>> done more than three years ago.
>>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>       Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates
>>>>>>>>> ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>       Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>       Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>       Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>
>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM
>>>>>>>> that
>>>>>>>> does either
>>>>>>>
>>>>>>> What I am claiming is that the above shows that if embedded_H
>>>>>>> rejected
>>>>>>> its input it would be correct.
>>>>>>
>>>>>> So what?  We are interested in the halting problem and your claim to
>>>>>> have addressed the key case: to have an H such that either
>>>>>
>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>>> is impossible.
>>>> No.  Linz's H is such that neither
>>>>        H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>> nor
>>>>        H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>>> is possible.
>>>
>>> Like I said I am not talking about H.
>>> I have not been talking about H for many months.
>>
>> There's no need to keep repeating that.  I understand 100% that you are
>> not talking about, and don't want to talk about, your H.
>>
>> If you really don't want to talk about your H, don't reply.  I'll say
>> what I like about it in peace.  But you can't offer any response to my
>> posts about it if you won't talk about it.
>>
>
> I am only talking about the simulating halt decider that is embedded in
> the middle of the Linz Ĥ at Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>

So, it still makes that exact same mistake.

>>> Also the key thing that you make sure to ignore is that it is never
>>> the case that any decider reports on the behavior of the computation
>>> that contains itself. Decider's are not capable of reporting on the
>>> behavior of Turing machines they can only accept or reject finite
>>> string inputs.
>>
>> I don't ignore it, I tell you that you are wrong -- every time you bring
>> it up.  What's more, I have, on multiple occasions, said that I can
>> offer you a series of exercises that, if you were to take them
>> seriously, might lead you to see why you are wrong.
>>
>> This is one of your favourite themes.  You accuse people of ignoring
>> something that they have answered every time you bring it up.  But,
>> unlike a crank, I will answer it every time you ask: you are wrong.  Of
>> course deciders are capable of reporting on the behaviour of Turing
>> machines.
>>
>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
>>>>> in a finite number of steps.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
>>>>> state in any finite number of steps.
>>>>
>>>> Still don't care about this H of yours.  You hooked people in with a
>>>> lie
>>>> that you kept repeating: your H is Linz's H.  At least you've come
>>>> clean
>>>> now and are attempting a hand-waving definition of your H.
>>
>> So the situation is
>
> That you cannot pay attention to the fact that when the simulating halt
> decider embedded within Linz Ĥ at Ĥ.qx would reject its input it would
> be correct and refute the Linz proof.
>

How is saying <H^> <H^> represents a Non-Halting Computation is correct
when H^ applied to <H^> and UTM applied to <H^> <H^> (the two possible
definitions of Halting) both show that it is Halting?

> https://www.liarparadox.org/Linz_Proof.pdf
>
>> that no one cares about your H and you dare not talk
>> about it!  There is nothing substantive to discuss if you won't talk
>> about the big mistakes.
>>
>
> This is verbatim Linz except it has been adapted to my clearer
> notational conventions:
>
> <Linz quote>
>     Now Ĥ is a Turing machine, so that it will have some description in
> Σ*, say ⟨Ĥ⟩. This string, in addition to being the description of Ĥ can
> also be used as input string. We can therefore legitimately ask what
> would happen if Ĥ is applied to ⟨Ĥ⟩.
>
>                  Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>
> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>
>                  Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> if Ĥ applied to ⟨Ĥ⟩ does not halt. This is clearly nonsense. The
> contradiction tells us that our assumption of the existence of H, and
> hence the assumption of the decidability of the halting problem, must be
> false
> </Linz quote>
>
> The copy of Linz H embedded at Ĥ.qx will be referred to as embedded_H
>
> Linz is confused into believing that embedded_H is reporting on the
> behavior of the computation that contains itself Ĥ applied to ⟨Ĥ⟩,
> rather than the behavior specified by its input: ⟨Ĥ⟩, ⟨Ĥ⟩.
>
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
> THE KEY THING THAT YOU KEEP IGNORING IS
>
> It is never the case that any decider reports on the behavior of the
> computation that contains itself. Deciders are not capable of reporting
> on the behavior of Turing machines they can only accept or reject finite
> string inputs.
>

On 3/7/22 6:14 PM, olcott wrote:
> On 3/7/2022 5:05 PM, Ben Bacarisse wrote:
>> Mike Terry <news.dead.person.stones@darjeeling.plus.com> writes:
>>
>>> On 07/03/2022 22:13, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>>>> maintained any damn thing that correctly determines that
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>>>
>>>>>>>>>>>> Not "any damn thing", no.  It must be the supposed halt
>>>>>>>>>>>> determiner, H,
>>>>>>>>>>>> that correctly determines it.  Now that might be what you
>>>>>>>>>>>> are trying to
>>>>>>>>>>>> so say with the mysterious "its", but then putting in "any
>>>>>>>>>>>> damn thing"
>>>>>>>>>>>> is just daft.
>>>>>>>>>>>>
>>>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>>>> or
>>>>>>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input
>>>>>>>>>>>> ⟨Ĥ⟩,
>>>>>>>>>>>> then you will have done the impossible thing what you
>>>>>>>>>>>> claimed to have
>>>>>>>>>>>> done more than three years ago.
>>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>        Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>
>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>        Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>        Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>        Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>
>>>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an
>>>>>>>>>> TM that
>>>>>>>>>> does either
>>>>>>>>>
>>>>>>>>> What I am claiming is that the above shows that if embedded_H
>>>>>>>>> rejected
>>>>>>>>> its input it would be correct.
>>>>>>>>
>>>>>>>> So what?  We are interested in the halting problem and your
>>>>>>>> claim to
>>>>>>>> have addressed the key case: to have an H such that either
>>>>>>>
>>>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says
>>>>>>> this
>>>>>>> is impossible.
>>>>>> No.  Linz's H is such that neither
>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>> nor
>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>> is possible.
>>>>>
>>>>> Like I said I am not talking about H.
>>>>> I have not been talking about H for many months.
>>>> There's no need to keep repeating that.  I understand 100% that you are
>>>> not talking about, and don't want to talk about, your H.
>>>
>>> When PO says "not talking about H" does that mean "not talking about
>>> PO's H" as you're thinking, or does it mean "not talking about Linz's
>>> H - I'm talking about Linz's Ĥ which contains a /copy/ of H that I'm
>>> calling embedded_H" ?
>>
>> I think it's both.  He's walking a tightrope: if it is too obvious that
>> what he calls H is not Linz's H, the game will be up.  But if he is
>> explicit that he means H as Linz does, the game is also up!
>>
>
> The only difference between embedded_H and a copy of the Linz H is that
> embedded_H is not an ALL KNOWING halt decider it is merely a simulating
> halt determiner that correctly determines that its input ⟨Ĥ⟩ ⟨Ĥ⟩ never
> halts, thus refuting the Linz proof that says this is impossible.
>

And it can't even do THAT, since if embedded_H goes to H.Qn, then H^
applied to <H^> HALT, and thus embedded_H FAILS to meet its requirement
that the DEFINITION says it must to be a correct Halt Decider.

olcott <NoOne@NoWhere.com> writes:

> On 3/7/2022 4:13 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>
>>>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>>>> is just daft.
>>>>>>>>>>
>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>> or
>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>>>> done more than three years ago.
>>>>>>>>>>
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>
>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>
>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>
>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>>>> does either
>>>>>>>
>>>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>>>> its input it would be correct.
>>>>>>
>>>>>> So what? We are interested in the halting problem and your claim to
>>>>>> have addressed the key case: to have an H such that either
>>>>>
>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>>> is impossible.
>>>> No. Linz's H is such that neither
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>> nor
>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>> is possible.
>>>
>>> Like I said I am not talking about H.
>>> I have not been talking about H for many months.
>> There's no need to keep repeating that. I understand 100% that you are
>> not talking about, and don't want to talk about, your H.
>> If you really don't want to talk about your H, don't reply. I'll say
>> what I like about it in peace. But you can't offer any response to my
>> posts about it if you won't talk about it.
>
> I am only talking about the simulating halt decider that is embedded
> in the middle of the Linz Ĥ at Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.

Oh, you are talking about Linz's H and Ĥ. OK. To "refute the proof"
(as you put it) you'd need a TM that that does either

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
or
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩

But you don't (though you once said you did). Unsurprisingly, the proof
is solid. Such an H is impossible.

>>> Also the key thing that you make sure to ignore is that it is never
>>> the case that any decider reports on the behavior of the computation
>>> that contains itself. Decider's are not capable of reporting on the
>>> behavior of Turing machines they can only accept or reject finite
>>> string inputs.
>>
>> I don't ignore it, I tell you that you are wrong -- every time you bring
>> it up. What's more, I have, on multiple occasions, said that I can
>> offer you a series of exercises that, if you were to take them
>> seriously, might lead you to see why you are wrong.
>> This is one of your favourite themes. You accuse people of ignoring
>> something that they have answered every time you bring it up. But,
>> unlike a crank, I will answer it every time you ask: you are wrong. Of
>> course deciders are capable of reporting on the behaviour of Turing
>> machines.

So are you not interested in this fundamental error anymore? I suppose
you need to wait a bit before saying I'm ignoring this point again!

>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
>>>>> in a finite number of steps.
>>>>>
>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
>>>>> state in any finite number of steps.
>>>>
>>>> Still don't care about this H of yours. You hooked people in with a lie
>>>> that you kept repeating: your H is Linz's H. At least you've come clean
>>>> now and are attempting a hand-waving definition of your H.
>> So the situation is
>
> That you cannot pay attention to the fact that when the simulating
> halt decider embedded within Linz Ĥ at Ĥ.qx would reject its input it
> would be correct and refute the Linz proof.

No. To "refute the proof" you need an H that does either

H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
or
H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩

but you won't even talk about H!

Anyway, with cranks, silence is often the only answer one can get, so I
can do no more than take your silence on this point as consent: you have
no such TM and never did.

After all, you've spent years walking back this claim, to the extent
that you were recently touting a decider for some made up problem of
your own that is not the halting problem.

>> that no one cares about your H and you dare not talk
>> about it! There is nothing substantive to discuss if you won't talk
>> about the big mistakes.
>>
>
> This is verbatim Linz except it has been adapted to my clearer
> notational conventions:
>
> <Linz quote>
> Now Ĥ is a Turing machine, so that it will have some description
> in Σ*, say ⟨Ĥ⟩. This string, in addition to being the description of Ĥ
> can also be used as input string. We can therefore legitimately ask
> what would happen if Ĥ is applied to ⟨Ĥ⟩.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>
> if Ĥ applied to ⟨Ĥ⟩ halts, and
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> if Ĥ applied to ⟨Ĥ⟩ does not halt. This is clearly nonsense. The
> contradiction tells us that our assumption of the existence of H, and
> hence the assumption of the decidability of the halting problem, must
> be false.
> </Linz quote>
>
> The copy of Linz H embedded at Ĥ.qx will be referred to as embedded_H
>
> Linz is confused into believing that embedded_H is reporting on the
> behavior of the computation that contains itself Ĥ applied to ⟨Ĥ⟩,
> rather than the behavior specified by its input: ⟨Ĥ⟩, ⟨Ĥ⟩.

On 3/7/2022 8:36 PM, Ben Bacarisse wrote:
> olcott <NoOne@NoWhere.com> writes:
>
>> On 3/7/2022 4:13 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>>> maintained any damn thing that correctly determines that ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>>
>>>>>>>>>>> Not "any damn thing", no. It must be the supposed halt determiner, H,
>>>>>>>>>>> that correctly determines it. Now that might be what you are trying to
>>>>>>>>>>> so say with the mysterious "its", but then putting in "any damn thing"
>>>>>>>>>>> is just daft.
>>>>>>>>>>>
>>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>>> or
>>>>>>>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>>>>>> then you will have done the impossible thing what you claimed to have
>>>>>>>>>>> done more than three years ago.
>>>>>>>>>>>
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>
>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>> Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>
>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>> Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>> Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>> Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>
>>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an TM that
>>>>>>>>> does either
>>>>>>>>
>>>>>>>> What I am claiming is that the above shows that if embedded_H rejected
>>>>>>>> its input it would be correct.
>>>>>>>
>>>>>>> So what? We are interested in the halting problem and your claim to
>>>>>>> have addressed the key case: to have an H such that either
>>>>>>
>>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says this
>>>>>> is impossible.
>>>>> No. Linz's H is such that neither
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
>>>>> nor
>>>>> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>> is possible.
>>>>
>>>> Like I said I am not talking about H.
>>>> I have not been talking about H for many months.
>>> There's no need to keep repeating that. I understand 100% that you are
>>> not talking about, and don't want to talk about, your H.
>>> If you really don't want to talk about your H, don't reply. I'll say
>>> what I like about it in peace. But you can't offer any response to my
>>> posts about it if you won't talk about it.
>>
>> I am only talking about the simulating halt decider that is embedded
>> in the middle of the Linz Ĥ at Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>
> Oh, you are talking about Linz's H and Ĥ. OK. To "refute the proof"
> (as you put it) you'd need a TM that that does either
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
> or
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩
>
> But you don't (though you once said you did). Unsurprisingly, the proof
> is solid. Such an H is impossible.
>
>>>> Also the key thing that you make sure to ignore is that it is never
>>>> the case that any decider reports on the behavior of the computation
>>>> that contains itself. Decider's are not capable of reporting on the
>>>> behavior of Turing machines they can only accept or reject finite
>>>> string inputs.
>>>
>>> I don't ignore it, I tell you that you are wrong -- every time you bring
>>> it up. What's more, I have, on multiple occasions, said that I can
>>> offer you a series of exercises that, if you were to take them
>>> seriously, might lead you to see why you are wrong.
>>> This is one of your favourite themes. You accuse people of ignoring
>>> something that they have answered every time you bring it up. But,
>>> unlike a crank, I will answer it every time you ask: you are wrong. Of
>>> course deciders are capable of reporting on the behaviour of Turing
>>> machines.
>
> So are you not interested in this fundamental error anymore? I suppose
> you need to wait a bit before saying I'm ignoring this point again!
>
>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final state
>>>>>> in a finite number of steps.
>>>>>>
>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own final
>>>>>> state in any finite number of steps.
>>>>>
>>>>> Still don't care about this H of yours. You hooked people in with a lie
>>>>> that you kept repeating: your H is Linz's H. At least you've come clean
>>>>> now and are attempting a hand-waving definition of your H.
>>> So the situation is
>>
>> That you cannot pay attention to the fact that when the simulating
>> halt decider embedded within Linz Ĥ at Ĥ.qx would reject its input it
>> would be correct and refute the Linz proof.
>
> No. To "refute the proof" you need an H that does either
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
> or
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩
>
> but you won't even talk about H!
>
> Anyway, with cranks, silence is often the only answer one can get, so I
> can do no more than take your silence on this point as consent: you have
> no such TM and never did.
>
> After all, you've spent years walking back this claim, to the extent
> that you were recently touting a decider for some made up problem of
> your own that is not the halting problem.
>
>>> that no one cares about your H and you dare not talk
>>> about it! There is nothing substantive to discuss if you won't talk
>>> about the big mistakes.
>>>
>>
>> This is verbatim Linz except it has been adapted to my clearer
>> notational conventions:
>>
>> <Linz quote>
>> Now Ĥ is a Turing machine, so that it will have some description
>> in Σ*, say ⟨Ĥ⟩. This string, in addition to being the description of Ĥ
>> can also be used as input string. We can therefore legitimately ask
>> what would happen if Ĥ is applied to ⟨Ĥ⟩.
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>
>> if Ĥ applied to ⟨Ĥ⟩ halts, and
>>
>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>
>> if Ĥ applied to ⟨Ĥ⟩ does not halt. This is clearly nonsense. The
>> contradiction tells us that our assumption of the existence of H, and
>> hence the assumption of the decidability of the halting problem, must
>> be false.
>> </Linz quote>
>>
>> The copy of Linz H embedded at Ĥ.qx will be referred to as embedded_H
>>
>> Linz is confused into believing that embedded_H is reporting on the
>> behavior of the computation that contains itself Ĥ applied to ⟨Ĥ⟩,
>> rather than the behavior specified by its input: ⟨Ĥ⟩, ⟨Ĥ⟩.
>
> No he is not. No mention at all is made of what embedded_H reports.
> The nonsense is simply that
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞ if Ĥ applied to ⟨Ĥ⟩ halts, and
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn if Ĥ applied to ⟨Ĥ⟩ does not halt.
>
> Your only hope of removing this contradiction is to change the
> conditions on those lines. That's the ruse you've been trying to pull
> for months with your pompous "Halt status criterion measure", but I
> suppose you've realised that won't wash so, at least for today, we are
> back to Linz's H and his correct criterion: halting.
>
> But there was a time you made a bolder claim: to have an H that gave the
> correct answer for this one case -- a TM that does either
>
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy when Ĥ halts on input ⟨Ĥ⟩,
> or
> H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn when Ĥ does not halt on input ⟨Ĥ⟩.
>
> But you no longer make that (impossible) claim.
>
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>> THE KEY THING THAT YOU KEEP IGNORING IS
>
> That you act like an over-tired six year old? I do try to ignore that.
>
>> It is never the case that any decider reports on the behavior of the
>> computation that contains itself. Deciders are not capable of
>> reporting on the behavior of Turing machines they can only accept or
>> reject finite string inputs.
>
> I keep addressing this. Again: you are wrong, Deciders /are/ capable of
> reporting on the behavior of Turing machines.

On 3/7/22 10:29 PM, olcott wrote:
> On 3/7/2022 8:36 PM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 3/7/2022 4:13 PM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>
>>>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>>>> maintained any damn thing that correctly determines that
>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>>>
>>>>>>>>>>>> Not "any damn thing", no.  It must be the supposed halt
>>>>>>>>>>>> determiner, H,
>>>>>>>>>>>> that correctly determines it.  Now that might be what you
>>>>>>>>>>>> are trying to
>>>>>>>>>>>> so say with the mysterious "its", but then putting in "any
>>>>>>>>>>>> damn thing"
>>>>>>>>>>>> is just daft.
>>>>>>>>>>>>
>>>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>>>> or
>>>>>>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input
>>>>>>>>>>>> ⟨Ĥ⟩,
>>>>>>>>>>>> then you will have done the impossible thing what you
>>>>>>>>>>>> claimed to have
>>>>>>>>>>>> done more than three years ago.
>>>>>>>>>>>>
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>
>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>        Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>
>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>        Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>        Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>        Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>
>>>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an
>>>>>>>>>> TM that
>>>>>>>>>> does either
>>>>>>>>>
>>>>>>>>> What I am claiming is that the above shows that if embedded_H
>>>>>>>>> rejected
>>>>>>>>> its input it would be correct.
>>>>>>>>
>>>>>>>> So what?  We are interested in the halting problem and your
>>>>>>>> claim to
>>>>>>>> have addressed the key case: to have an H such that either
>>>>>>>
>>>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says
>>>>>>> this
>>>>>>> is impossible.
>>>>>> No.  Linz's H is such that neither
>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>> nor
>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>> is possible.
>>>>>
>>>>> Like I said I am not talking about H.
>>>>> I have not been talking about H for many months.
>>>> There's no need to keep repeating that.  I understand 100% that you are
>>>> not talking about, and don't want to talk about, your H.
>>>> If you really don't want to talk about your H, don't reply.  I'll say
>>>> what I like about it in peace.  But you can't offer any response to my
>>>> posts about it if you won't talk about it.
>>>
>>> I am only talking about the simulating halt decider that is embedded
>>> in the middle of the Linz Ĥ at Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>
>> Oh, you are talking about Linz's H and Ĥ.  OK.  To "refute the proof"
>> (as you put it) you'd need a TM that that does either
>>
>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>> or
>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩
>>
>> But you don't (though you once said you did).  Unsurprisingly, the proof
>> is solid.  Such an H is impossible.
>>
>>>>> Also the key thing that you make sure to ignore is that it is never
>>>>> the case that any decider reports on the behavior of the computation
>>>>> that contains itself. Decider's are not capable of reporting on the
>>>>> behavior of Turing machines they can only accept or reject finite
>>>>> string inputs.
>>>>
>>>> I don't ignore it, I tell you that you are wrong -- every time you
>>>> bring
>>>> it up.  What's more, I have, on multiple occasions, said that I can
>>>> offer you a series of exercises that, if you were to take them
>>>> seriously, might lead you to see why you are wrong.
>>>> This is one of your favourite themes.  You accuse people of ignoring
>>>> something that they have answered every time you bring it up.  But,
>>>> unlike a crank, I will answer it every time you ask: you are wrong.  Of
>>>> course deciders are capable of reporting on the behaviour of Turing
>>>> machines.
>>
>> So are you not interested in this fundamental error anymore?  I suppose
>> you need to wait a bit before saying I'm ignoring this point again!
>>
>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final
>>>>>>> state
>>>>>>> in a finite number of steps.
>>>>>>>
>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own
>>>>>>> final
>>>>>>> state in any finite number of steps.
>>>>>>
>>>>>> Still don't care about this H of yours.  You hooked people in with
>>>>>> a lie
>>>>>> that you kept repeating: your H is Linz's H.  At least you've come
>>>>>> clean
>>>>>> now and are attempting a hand-waving definition of your H.
>>>> So the situation is
>>>
>>> That you cannot pay attention to the fact that when the simulating
>>> halt decider embedded within Linz Ĥ at Ĥ.qx would reject its input it
>>> would be correct and refute the Linz proof.
>>
>> No.  To "refute the proof" you need an H that does either
>>
>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>> or
>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩
>>
>> but you won't even talk about H!
>>
>> Anyway, with cranks, silence is often the only answer one can get, so I
>> can do no more than take your silence on this point as consent: you have
>> no such TM and never did.
>>
>> After all, you've spent years walking back this claim, to the extent
>> that you were recently touting a decider for some made up problem of
>> your own that is not the halting problem.
>>
>>>> that no one cares about your H and you dare not talk
>>>> about it!  There is nothing substantive to discuss if you won't talk
>>>> about the big mistakes.
>>>>
>>>
>>> This is verbatim Linz except it has been adapted to my clearer
>>> notational conventions:
>>>
>>> <Linz quote>
>>>      Now Ĥ is a Turing machine, so that it will have some description
>>> in Σ*, say ⟨Ĥ⟩. This string, in addition to being the description of Ĥ
>>> can also be used as input string. We can therefore legitimately ask
>>> what would happen if Ĥ is applied to ⟨Ĥ⟩.
>>>
>>>                   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>
>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>
>>>                   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>
>>> if Ĥ applied to ⟨Ĥ⟩ does not halt. This is clearly nonsense. The
>>> contradiction tells us that our assumption of the existence of H, and
>>> hence the assumption of the decidability of the halting problem, must
>>> be false.
>>> </Linz quote>
>>>
>>> The copy of Linz H embedded at Ĥ.qx will be referred to as embedded_H
>>>
>>> Linz is confused into believing that embedded_H is reporting on the
>>> behavior of the computation that contains itself Ĥ applied to ⟨Ĥ⟩,
>>> rather than the behavior specified by its input: ⟨Ĥ⟩, ⟨Ĥ⟩.
>>
>> No he is not.  No mention at all is made of what embedded_H reports.
>> The nonsense is simply that
>>
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞     if Ĥ applied to ⟨Ĥ⟩ halts, and
>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn  if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>
>> Your only hope of removing this contradiction is to change the
>> conditions on those lines.  That's the ruse you've been trying to pull
>> for months with your pompous "Halt status criterion measure", but I
>> suppose you've realised that won't wash so, at least for today, we are
>> back to Linz's H and his correct criterion: halting.
>>
>> But there was a time you made a bolder claim: to have an H that gave the
>> correct answer for this one case -- a TM that does either
>>
>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>> or
>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩.
>>
>> But you no longer make that (impossible) claim.
>>
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>
>> That you act like an over-tired six year old?  I do try to ignore that.
>>
>>> It is never the case that any decider reports on the behavior of the
>>> computation that contains itself. Deciders are not capable of
>>> reporting on the behavior of Turing machines they can only accept or
>>> reject finite string inputs.
>>
>> I keep addressing this.  Again: you are wrong, Deciders /are/ capable of
>> reporting on the behavior of Turing machines.
>
> Deciders only compute the mapping from input finite strings to accept or
> reject states. If you disagree please provide a link that proves that
> deciders compute mappings from non-input non-strings.
>
> If you don't disagree then you know that embedded_H does not compute the
> mapping from Ĥ ⟨Ĥ⟩ (not an input and not finite a string) and does
> compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ (both an input and finite strings).
>
>

On 2022-03-05 11:53:50 +0000, Ben Bacarisse said:

> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2022-03-04 21:07:30 +0000, Ben Bacarisse said:
>>
>>> The words used don't alter the facts -- that there is no TM
>>> satisfying Linz's 12.1 can be, loosely, stated as "there is no
>>> decider for the strings that represent halting computations".
>>
>> Words can be (and often are) used to hide facts.
>
> But not, as far as I can see, in this case. The meaning of "decider" --
> a TM whose language is decidable -- is not causing any confusion. OK,
> PO lies about what other people say and/or know about "deciders", but
> the fault there is in the lying, not in the words used.

In this case the probable intent was to argue about an irrelevance in
order to draw attention from the fact that the presented soulution does
not satisfy the definitiopn (21.1) of a solution to the halting problem.

Mikko

Mikko <mikko.levanto@iki.fi> writes:

> On 2022-03-05 11:53:50 +0000, Ben Bacarisse said:
>
>> Mikko <mikko.levanto@iki.fi> writes:
>>
>>> On 2022-03-04 21:07:30 +0000, Ben Bacarisse said:
>>>
>>>> The words used don't alter the facts -- that there is no TM
>>>> satisfying Linz's 12.1 can be, loosely, stated as "there is no
>>>> decider for the strings that represent halting computations".
>>> Words can be (and often are) used to hide facts.
>> But not, as far as I can see, in this case. The meaning of "decider" --
>> a TM whose language is decidable -- is not causing any confusion. OK,
>> PO lies about what other people say and/or know about "deciders", but
>> the fault there is in the lying, not in the words used.
>
> In this case the probable intent was to argue about an irrelevance in
> order to draw attention from the fact that the presented soulution does
> not satisfy the definitiopn (21.1) of a solution to the halting
> problem.

That's possible.

--
Ben.

On 3/7/2022 9:57 PM, Richard Damon wrote:
> On 3/7/22 10:29 PM, olcott wrote:
>> On 3/7/2022 8:36 PM, Ben Bacarisse wrote:
>>> olcott <NoOne@NoWhere.com> writes:
>>>
>>>> On 3/7/2022 4:13 PM, Ben Bacarisse wrote:
>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>
>>>>>> On 3/7/2022 1:16 PM, Ben Bacarisse wrote:
>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>
>>>>>>>> On 3/7/2022 10:53 AM, Ben Bacarisse wrote:
>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>
>>>>>>>>>> On 3/7/2022 5:07 AM, Ben Bacarisse wrote:
>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>> On 3/6/2022 8:46 PM, Ben Bacarisse wrote:
>>>>>>>>>>>>> I'm getting bored so I will skip to the chase at the end..
>>>>>>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>>>>
>>>>>>>>>>>>>> As long as the Linz Ĥ relationship to its halt determiner is
>>>>>>>>>>>>>> maintained any damn thing that correctly determines that
>>>>>>>>>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ never
>>>>>>>>>>>>>> halts defeats the Linz proof.
>>>>>>>>>>>>>
>>>>>>>>>>>>> Not "any damn thing", no.  It must be the supposed halt
>>>>>>>>>>>>> determiner, H,
>>>>>>>>>>>>> that correctly determines it.  Now that might be what you
>>>>>>>>>>>>> are trying to
>>>>>>>>>>>>> so say with the mysterious "its", but then putting in "any
>>>>>>>>>>>>> damn thing"
>>>>>>>>>>>>> is just daft.
>>>>>>>>>>>>>
>>>>>>>>>>>>> More clearly, if you have an TM H such that either
>>>>>>>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>>>>>>>> or
>>>>>>>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on
>>>>>>>>>>>>> input ⟨Ĥ⟩,
>>>>>>>>>>>>> then you will have done the impossible thing what you
>>>>>>>>>>>>> claimed to have
>>>>>>>>>>>>> done more than three years ago.
>>>>>>>>>>>>>
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>>>>>>
>>>>>>>>>>>> When Ĥ is applied to ⟨Ĥ⟩
>>>>>>>>>>>>        Ĥ copies its input ⟨Ĥ1⟩ to ⟨Ĥ2⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ1⟩ ⟨Ĥ2⟩
>>>>>>>>>>>>
>>>>>>>>>>>> Then these steps would keep repeating:
>>>>>>>>>>>>        Ĥ1 copies its input ⟨Ĥ2⟩ to ⟨Ĥ3⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ2⟩ ⟨Ĥ3⟩
>>>>>>>>>>>>        Ĥ2 copies its input ⟨Ĥ3⟩ to ⟨Ĥ4⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ3⟩ ⟨Ĥ4⟩
>>>>>>>>>>>>        Ĥ3 copies its input ⟨Ĥ4⟩ to ⟨Ĥ5⟩ then embedded_H
>>>>>>>>>>>> simulates ⟨Ĥ4⟩ ⟨Ĥ5⟩...
>>>>>>>>>>>
>>>>>>>>>>> So, just to be 100% clear, you are /not/ claiming to have an
>>>>>>>>>>> TM that
>>>>>>>>>>> does either
>>>>>>>>>>
>>>>>>>>>> What I am claiming is that the above shows that if embedded_H
>>>>>>>>>> rejected
>>>>>>>>>> its input it would be correct.
>>>>>>>>>
>>>>>>>>> So what?  We are interested in the halting problem and your
>>>>>>>>> claim to
>>>>>>>>> have addressed the key case: to have an H such that either
>>>>>>>>
>>>>>>>> The copy of Linz H embedded at Ĥ.qx would correctly decide that its
>>>>>>>> input ⟨Ĥ⟩ ⟨Ĥ⟩ never halts thus refuting the Linz proof that says
>>>>>>>> this
>>>>>>>> is impossible.
>>>>>>> No.  Linz's H is such that neither
>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>>>>>> nor
>>>>>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩,
>>>>>>> is possible.
>>>>>>
>>>>>> Like I said I am not talking about H.
>>>>>> I have not been talking about H for many months.
>>>>> There's no need to keep repeating that.  I understand 100% that you
>>>>> are
>>>>> not talking about, and don't want to talk about, your H.
>>>>> If you really don't want to talk about your H, don't reply.  I'll say
>>>>> what I like about it in peace.  But you can't offer any response to my
>>>>> posts about it if you won't talk about it.
>>>>
>>>> I am only talking about the simulating halt decider that is embedded
>>>> in the middle of the Linz Ĥ at Ĥ.qx applied to ⟨Ĥ⟩ ⟨Ĥ⟩.
>>>
>>> Oh, you are talking about Linz's H and Ĥ.  OK.  To "refute the proof"
>>> (as you put it) you'd need a TM that that does either
>>>
>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>> or
>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩
>>>
>>> But you don't (though you once said you did).  Unsurprisingly, the proof
>>> is solid.  Such an H is impossible.
>>>
>>>>>> Also the key thing that you make sure to ignore is that it is never
>>>>>> the case that any decider reports on the behavior of the computation
>>>>>> that contains itself. Decider's are not capable of reporting on the
>>>>>> behavior of Turing machines they can only accept or reject finite
>>>>>> string inputs.
>>>>>
>>>>> I don't ignore it, I tell you that you are wrong -- every time you
>>>>> bring
>>>>> it up.  What's more, I have, on multiple occasions, said that I can
>>>>> offer you a series of exercises that, if you were to take them
>>>>> seriously, might lead you to see why you are wrong.
>>>>> This is one of your favourite themes.  You accuse people of ignoring
>>>>> something that they have answered every time you bring it up.  But,
>>>>> unlike a crank, I will answer it every time you ask: you are
>>>>> wrong.  Of
>>>>> course deciders are capable of reporting on the behaviour of Turing
>>>>> machines.
>>>
>>> So are you not interested in this fundamental error anymore?  I suppose
>>> you need to wait a bit before saying I'm ignoring this point again!
>>>
>>>>>>>> https://www.liarparadox.org/Peter_Linz_HP_317-320.pdf
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would reach its own final
>>>>>>>> state
>>>>>>>> in a finite number of steps.
>>>>>>>>
>>>>>>>> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>>>>> if the simulated ⟨Ĥ⟩ ⟨Ĥ⟩ by embedded_H would never reach its own
>>>>>>>> final
>>>>>>>> state in any finite number of steps.
>>>>>>>
>>>>>>> Still don't care about this H of yours.  You hooked people in
>>>>>>> with a lie
>>>>>>> that you kept repeating: your H is Linz's H.  At least you've
>>>>>>> come clean
>>>>>>> now and are attempting a hand-waving definition of your H.
>>>>> So the situation is
>>>>
>>>> That you cannot pay attention to the fact that when the simulating
>>>> halt decider embedded within Linz Ĥ at Ĥ.qx would reject its input it
>>>> would be correct and refute the Linz proof.
>>>
>>> No.  To "refute the proof" you need an H that does either
>>>
>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>> or
>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩
>>>
>>> but you won't even talk about H!
>>>
>>> Anyway, with cranks, silence is often the only answer one can get, so I
>>> can do no more than take your silence on this point as consent: you have
>>> no such TM and never did.
>>>
>>> After all, you've spent years walking back this claim, to the extent
>>> that you were recently touting a decider for some made up problem of
>>> your own that is not the halting problem.
>>>
>>>>> that no one cares about your H and you dare not talk
>>>>> about it!  There is nothing substantive to discuss if you won't talk
>>>>> about the big mistakes.
>>>>>
>>>>
>>>> This is verbatim Linz except it has been adapted to my clearer
>>>> notational conventions:
>>>>
>>>> <Linz quote>
>>>>      Now Ĥ is a Turing machine, so that it will have some description
>>>> in Σ*, say ⟨Ĥ⟩. This string, in addition to being the description of Ĥ
>>>> can also be used as input string. We can therefore legitimately ask
>>>> what would happen if Ĥ is applied to ⟨Ĥ⟩.
>>>>
>>>>                   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qy ∞
>>>>
>>>> if Ĥ applied to  ⟨Ĥ⟩ halts, and
>>>>
>>>>                   Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>>>>
>>>> if Ĥ applied to ⟨Ĥ⟩ does not halt. This is clearly nonsense. The
>>>> contradiction tells us that our assumption of the existence of H, and
>>>> hence the assumption of the decidability of the halting problem, must
>>>> be false.
>>>> </Linz quote>
>>>>
>>>> The copy of Linz H embedded at Ĥ.qx will be referred to as embedded_H
>>>>
>>>> Linz is confused into believing that embedded_H is reporting on the
>>>> behavior of the computation that contains itself Ĥ applied to ⟨Ĥ⟩,
>>>> rather than the behavior specified by its input: ⟨Ĥ⟩, ⟨Ĥ⟩.
>>>
>>> No he is not.  No mention at all is made of what embedded_H reports.
>>> The nonsense is simply that
>>>
>>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* ∞     if Ĥ applied to ⟨Ĥ⟩ halts, and
>>>    Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qn  if Ĥ applied to ⟨Ĥ⟩ does not halt.
>>>
>>> Your only hope of removing this contradiction is to change the
>>> conditions on those lines.  That's the ruse you've been trying to pull
>>> for months with your pompous "Halt status criterion measure", but I
>>> suppose you've realised that won't wash so, at least for today, we are
>>> back to Linz's H and his correct criterion: halting.
>>>
>>> But there was a time you made a bolder claim: to have an H that gave the
>>> correct answer for this one case -- a TM that does either
>>>
>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qy   when Ĥ halts on input ⟨Ĥ⟩,
>>> or
>>>         H.q0 ⟨Ĥ⟩ ⟨Ĥ⟩ ⊦* H.qn   when Ĥ does not halt on input ⟨Ĥ⟩.
>>>
>>> But you no longer make that (impossible) claim.
>>>
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>> THE KEY THING THAT YOU KEEP IGNORING IS
>>>
>>> That you act like an over-tired six year old?  I do try to ignore that.
>>>
>>>> It is never the case that any decider reports on the behavior of the
>>>> computation that contains itself. Deciders are not capable of
>>>> reporting on the behavior of Turing machines they can only accept or
>>>> reject finite string inputs.
>>>
>>> I keep addressing this.  Again: you are wrong, Deciders /are/ capable of
>>> reporting on the behavior of Turing machines.
>>
>> Deciders only compute the mapping from input finite strings to accept
>> or reject states. If you disagree please provide a link that proves
>> that deciders compute mappings from non-input non-strings.
>>
>> If you don't disagree then you know that embedded_H does not compute
>> the mapping from Ĥ ⟨Ĥ⟩ (not an input and not finite a string) and does
>> compute the mapping from ⟨Ĥ⟩ ⟨Ĥ⟩ (both an input and finite strings).
>>
>>
>
> You do like your Herring Red don't you.
>
> NO ONE says that the decider maps something that isn't its input.
>
> H applied to <H^> <H^> needs to figure out what its input maps to.

On 3/8/2022 5:36 AM, Ben Bacarisse wrote:
> Mikko <mikko.levanto@iki.fi> writes:
>
>> On 2022-03-05 11:53:50 +0000, Ben Bacarisse said:
>>
>>> Mikko <mikko.levanto@iki.fi> writes:
>>>
>>>> On 2022-03-04 21:07:30 +0000, Ben Bacarisse said:
>>>>
>>>>> The words used don't alter the facts -- that there is no TM
>>>>> satisfying Linz's 12.1 can be, loosely, stated as "there is no
>>>>> decider for the strings that represent halting computations".
>>>> Words can be (and often are) used to hide facts.
>>> But not, as far as I can see, in this case. The meaning of "decider" --
>>> a TM whose language is decidable -- is not causing any confusion. OK,
>>> PO lies about what other people say and/or know about "deciders", but
>>> the fault there is in the lying, not in the words used.
>>
>> In this case the probable intent was to argue about an irrelevance in
>> order to draw attention from the fact that the presented soulution does
>> not satisfy the definitiopn (21.1) of a solution to the halting
>> problem.
>
> That's possible.
>

I conclusively proved that the simulated input to embedded_H ⟨Ĥ⟩ ⟨Ĥ⟩
never reaches its final state of ⟨Ĥ⟩.qn thus proving that embedded_H
would be correct to reject its input. This refutes the Linz proof that
concludes this is impossible.

--
Copyright 2021 Pete Olcott

Talent hits a target no one else can hit;
Genius hits a target no one else can see.
Arthur Schopenhauer