On 8/20/21 11:31 AM, olcott wrote:
> On 8/20/2021 10:10 AM, Ben Bacarisse wrote:
>> olcott <NoOne@NoWhere.com> writes:
>>
>>> On 8/20/2021 5:40 AM, Ben Bacarisse wrote:
>>>> olcott <NoOne@NoWhere.com> writes:
>>>>
>>>>> On 8/19/2021 8:05 PM, Ben Bacarisse wrote:
>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>
>>>>>>> On 8/19/2021 6:14 PM, Ben Bacarisse wrote:
>>>>>>>> olcott <NoOne@NoWhere.com> writes:
>>>>>>>>
>>>>>>>>> Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>> Yes.
>>>>>>>> And on the 12th Aug you said, and I quote
>>>>>>>>       "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting computation."
>>>>>>>> This is incorrect.  You need to correct that statement so you
>>>>>>>> can go on
>>>>>>>> to investigate the consequences.  It's not a trivial error.  It's
>>>>>>>> absolutely central to the case under investigation.
>>>>>>>>
>>>>>>>>> You are saying that Ĥ applied to ⟨Ĥ⟩ halts.
>>>>>>>> We are both saying that -- you said it above and of course I
>>>>>>>> agree.  The
>>>>>>>> point of disagreement is that you said
>>>>>>>>       "⟨Ĥ⟩ ⟨Ĥ⟩ is not a string that encodes a halting computation."
>>>>>>>> which is false.  ⟨Ĥ⟩ ⟨Ĥ⟩ /is/ a string that encodes a halting
>>>>>>>> computation.
>>>>>>>>
>>>>>>>>> I am saying that the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ never halts.
>>>>>>>>
>>>>>>>> I know you are.  That may or may not mean the same as "⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>>> is not a
>>>>>>>> string that encodes a halting computation" (I think its does
>>>>>>>> mean the
>>>>>>>> same, just poorly worded), but obviously I want to correct the
>>>>>>>> clear and
>>>>>>>> unambiguously wrong version from Aug 12th.  So long as you
>>>>>>>> refuse to
>>>>>>>> accept that ⟨Ĥ⟩ ⟨Ĥ⟩ is a string that encodes a halting computation,
>>>>>>>> discussion is pointless.
>>>>>>>
>>>>>>> You say that it encodes a halting computation because Ĥ applied
>>>>>>> to ⟨Ĥ⟩
>>>>>>> halts
>>>>>>
>>>>>> The string ⟨Ĥ⟩ ⟨Ĥ⟩ encodes the computation Ĥ(⟨Ĥ⟩) which, as we all
>>>>>> know,
>>>>>> is a halting computation.  That is why it is correct to say that
>>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> encodes a halting computation.  You say that ⟨Ĥ⟩ ⟨Ĥ⟩ is not a string
>>>>>> that encodes a halting computation because you are wrong.
>>>>>>
>>>>>>> yet this simply ignores that fact that the input to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>>> never halts.
>>>>>>
>>>>>> This is (as far as I can tell) meaningless.  On the other hand
>>>>>> "⟨Ĥ⟩ ⟨Ĥ⟩
>>>>>> is not a string that encodes a halting computation" is very clear and
>>>>>> very wrong.  Unless you accept that it's wrong everything you say is
>>>>>> suspect.
>>>>>
>>>>> Because the input to Ĥ has the pathological self-reference that
>>>>> Flibble objected to:
>>>>>
>>>>>      Now we construct a new Turing machine D with H as a subroutine.
>>>>>      This new TM calls H to determine what M does when the input to
>>>>>      M is its own description ⟨M⟩. Once D has determined this
>>>>> information,
>>>>>      it does the opposite.  (Sipser:1997:165)
>>>>>
>>>>> ⟨Ĥ⟩ ⟨Ĥ⟩ is like https://en.wikipedia.org/wiki/Schr%C3%B6dinger%27s_cat
>>>>> "the cat remains both alive and dead"
>>>>
>>>> No.  You claim to have a TM H.  From that Ĥ can be constructed.  The
>>>> encoding of that TM is ⟨Ĥ⟩.  When Ĥ applied to ⟨Ĥ⟩ the computation
>>>> comes
>>>> to a halt.  ⟨Ĥ⟩ ⟨Ĥ⟩ is the string the represents that halting
>>>> computation.  A halt decider must accept that string.  Many will.
>>>>
>>>> Every instance of the halting problem (and the string ⟨Ĥ⟩ ⟨Ĥ⟩ is
>>>> just an
>>>> instance of the halting problem) has a correct yes/no answer.  For the
>>>> instance ⟨Ĥ⟩ ⟨Ĥ⟩, the correct answer is yes, because that string
>>>> encodes
>>>> a halting computation as you have told us.
>>>>
>>>> Your H, whatever it does, simply fails to be a halt decider in at least
>>>> one case.  Sadly (for you), that is the case you have spent 17 years
>>>> on.
>>>
>>> I am not going to bother to answer all of this so that you can stay
>>> focused on one key point:
>>
>> You are not going to stay focused on the most serious error you have yet
>> posted? 
>
> You have to go though the following reasoning and point out the specific
> error. Making a blanket assertion that there is an error somewhere does
> not count as any rebuttal at all.
>
> Ĥ.q0 ⟨Ĥ⟩ ⊢* Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ ⊢* Ĥ.qn
>
> The first (executed) Ĥ has a dependency on these two (simulated) ⟨Ĥ⟩ ⟨Ĥ⟩
> that do not have a dependency on the first Ĥ, this makes their position
> in the execution trace have an effect on their behavior.

The first H^, is given as an input, <H^>, the representation of that
H^. H^ has a defined algorithm of what it will do to given that input.

The simulated <H^> <H^>, by definition of representation means that it
must execute in a UTM exactly like that H^ given <H^>. PERIOD.

There 'position' in the exection trace has ZERO impact on what there
actual behavior as machines.

Yes, H^, because it is not a real pure simulation, but only a partial
simulation, does create a full execution trace of its input, but that
doesn't make that input represent a non-halting computation, it just
leaves the execution state of the input unproven.

>
> Perhaps this is simply beyond your capacity to understand?
>
> When we define Ĵ to be exactly like Ĥ except that it has a UTM at Ĵ.qx
> instead of a simulating halt decider then we can see that Ĵ applied to
> ⟨Ĵ⟩ never halts.

So, J isn't H^, so that doesn't really mean anything about H^
>
> Ĵ.q0 ⟨Ĥ⟩ ⊢* Ĵ.qx ⟨Ĵ⟩ ⟨Ĵ⟩ ⊢* Ĵ.qn
>
> From this we can conclude that while the simulating halt decider at Ĥ.qx
> remains in pure simulation mode (thus not aborting the simulation of its
> input) Ĥ applied to ⟨Ĥ⟩ never halts.
>

But since it does abort its simulation, it isn't J. PERIOD.

H^ is not J

> Because we have already agreed that when the pure simulation of an input
> to a simulating halt decider never halts then this input is correctly
> decided as never halting then we can correctly conclude that the input
> to Ĥ.qx ⟨Ĥ⟩ ⟨Ĥ⟩ is correctly decided as never halting.

But a pure simulation until it is aborted is NOT a pure simulation. PERIOD.

UNSOUND logic.

>
>> A error that makes it plain, using a solid symbolic formalism
>> that your H is wrong?  OK.  That's up to you.  At some point you will
>> have to correct that error, but I am happy for you to leave it for now.
>> It means I can post it every now and then if I think there is a danger
>> someone might take you seriously.
>>
>> You need to start by agreeing that ⟨Ĥ⟩ ⟨Ĥ⟩ is a string that encodes a
>> halting computation. 
>
> You have to find the specific error in my rebuttal of this. Making a
> blanket assertion that there is an error somewhere does not count as any
> rebuttal at all.
>

See above, clearly pointed out Definition of Pure Simulation is
simulating until the machine terminates in a halt state. Acting like a
simulator for a while and then stopping is NOT a pure simulation, PERIOD.

If it reaches the halting state, it proves Halting (because then it DID
continue as long as the real pure simulator). If it stops before it
reaches that point, it is NOT a pure simulation and gives a different
result. Assuming that it gives the same result is UNSOUND logic.

>> How computations are encoded as strings, and which
>> strings should be accepted and which rejected, is the very essence of
>> the problem you wasted the last 17 years on.
>>
>
>